drivers/mfd/arizona-core.c

   1 /*
   2  * Arizona core driver
   3  *
   4  * Copyright 2012 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
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/clk.h>
  14 #include <linux/delay.h>
  15 #include <linux/err.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/mfd/core.h>
  19 #include <linux/module.h>
  20 #include <linux/of.h>
  21 #include <linux/of_device.h>
  22 #include <linux/pm_runtime.h>
  23 #include <linux/regmap.h>
  24 #include <linux/regulator/consumer.h>
  25 #include <linux/regulator/machine.h>
  26 #include <linux/slab.h>
  27 #include <linux/ktime.h>
  28 #include <linux/platform_device.h>
  29
  30 #include <linux/mfd/arizona/core.h>
  31 #include <linux/mfd/arizona/registers.h>
  32
  33 #include "arizona.h"
  34
  35 static const char * const wm5102_core_supplies[] = {
  36         "AVDD",
  37         "DBVDD1",
  38 };
  39
  40 int arizona_clk32k_enable(struct arizona *arizona)
  41 {
  42         int ret = 0;
  43
  44         mutex_lock(&arizona->clk_lock);
  45
  46         arizona->clk32k_ref++;
  47
  48         if (arizona->clk32k_ref == 1) {
  49                 switch (arizona->pdata.clk32k_src) {
  50                 case ARIZONA_32KZ_MCLK1:
  51                         ret = pm_runtime_get_sync(arizona->dev);
  52                         if (ret != 0)
  53                                 goto err_ref;
  54                         ret = clk_prepare_enable(arizona->mclk[ARIZONA_MCLK1]);
  55                         if (ret != 0) {
  56                                 pm_runtime_put_sync(arizona->dev);
  57                                 goto err_ref;
  58                         }
  59                         break;
  60                 case ARIZONA_32KZ_MCLK2:
  61                         ret = clk_prepare_enable(arizona->mclk[ARIZONA_MCLK2]);
  62                         if (ret != 0)
  63                                 goto err_ref;
  64                         break;
  65                 }
  66
  67                 ret = regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
  68                                          ARIZONA_CLK_32K_ENA,
  69                                          ARIZONA_CLK_32K_ENA);
  70         }
  71
  72 err_ref:
  73         if (ret != 0)
  74                 arizona->clk32k_ref--;
  75
  76         mutex_unlock(&arizona->clk_lock);
  77
  78         return ret;
  79 }
  80 EXPORT_SYMBOL_GPL(arizona_clk32k_enable);
  81
  82 int arizona_clk32k_disable(struct arizona *arizona)
  83 {
  84         mutex_lock(&arizona->clk_lock);
  85
  86         BUG_ON(arizona->clk32k_ref <= 0);
  87
  88         arizona->clk32k_ref--;
  89
  90         if (arizona->clk32k_ref == 0) {
  91                 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
  92                                    ARIZONA_CLK_32K_ENA, 0);
  93
  94                 switch (arizona->pdata.clk32k_src) {
  95                 case ARIZONA_32KZ_MCLK1:
  96                         pm_runtime_put_sync(arizona->dev);
  97                         clk_disable_unprepare(arizona->mclk[ARIZONA_MCLK1]);
  98                         break;
  99                 case ARIZONA_32KZ_MCLK2:
 100                         clk_disable_unprepare(arizona->mclk[ARIZONA_MCLK2]);
 101                         break;
 102                 }
 103         }
 104
 105         mutex_unlock(&arizona->clk_lock);
 106
 107         return 0;
 108 }
 109 EXPORT_SYMBOL_GPL(arizona_clk32k_disable);
 110
 111 static irqreturn_t arizona_clkgen_err(int irq, void *data)
 112 {
 113         struct arizona *arizona = data;
 114
 115         dev_err(arizona->dev, "CLKGEN error\n");
 116
 117         return IRQ_HANDLED;
 118 }
 119
 120 static irqreturn_t arizona_underclocked(int irq, void *data)
 121 {
 122         struct arizona *arizona = data;
 123         unsigned int val;
 124         int ret;
 125
 126         ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_8,
 127                           &val);
 128         if (ret != 0) {
 129                 dev_err(arizona->dev, "Failed to read underclock status: %d\n",
 130                         ret);
 131                 return IRQ_NONE;
 132         }
 133
 134         if (val & ARIZONA_AIF3_UNDERCLOCKED_STS)
 135                 dev_err(arizona->dev, "AIF3 underclocked\n");
 136         if (val & ARIZONA_AIF2_UNDERCLOCKED_STS)
 137                 dev_err(arizona->dev, "AIF2 underclocked\n");
 138         if (val & ARIZONA_AIF1_UNDERCLOCKED_STS)
 139                 dev_err(arizona->dev, "AIF1 underclocked\n");
 140         if (val & ARIZONA_ISRC3_UNDERCLOCKED_STS)
 141                 dev_err(arizona->dev, "ISRC3 underclocked\n");
 142         if (val & ARIZONA_ISRC2_UNDERCLOCKED_STS)
 143                 dev_err(arizona->dev, "ISRC2 underclocked\n");
 144         if (val & ARIZONA_ISRC1_UNDERCLOCKED_STS)
 145                 dev_err(arizona->dev, "ISRC1 underclocked\n");
 146         if (val & ARIZONA_FX_UNDERCLOCKED_STS)
 147                 dev_err(arizona->dev, "FX underclocked\n");
 148         if (val & ARIZONA_ASRC_UNDERCLOCKED_STS)
 149                 dev_err(arizona->dev, "ASRC underclocked\n");
 150         if (val & ARIZONA_DAC_UNDERCLOCKED_STS)
 151                 dev_err(arizona->dev, "DAC underclocked\n");
 152         if (val & ARIZONA_ADC_UNDERCLOCKED_STS)
 153                 dev_err(arizona->dev, "ADC underclocked\n");
 154         if (val & ARIZONA_MIXER_UNDERCLOCKED_STS)
 155                 dev_err(arizona->dev, "Mixer dropped sample\n");
 156
 157         return IRQ_HANDLED;
 158 }
 159
 160 static irqreturn_t arizona_overclocked(int irq, void *data)
 161 {
 162         struct arizona *arizona = data;
 163         unsigned int val[3];
 164         int ret;
 165
 166         ret = regmap_bulk_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_6,
 167                                &val[0], 3);
 168         if (ret != 0) {
 169                 dev_err(arizona->dev, "Failed to read overclock status: %d\n",
 170                         ret);
 171                 return IRQ_NONE;
 172         }
 173
 174         switch (arizona->type) {
 175         case WM8998:
 176         case WM1814:
 177                 /* Some bits are shifted on WM8998,
 178                  * rearrange to match the standard bit layout
 179                  */
 180                 val[0] = ((val[0] & 0x60e0) >> 1) |
 181                          ((val[0] & 0x1e00) >> 2) |
 182                          (val[0] & 0x000f);
 183                 break;
 184         default:
 185                 break;
 186         }
 187
 188         if (val[0] & ARIZONA_PWM_OVERCLOCKED_STS)
 189                 dev_err(arizona->dev, "PWM overclocked\n");
 190         if (val[0] & ARIZONA_FX_CORE_OVERCLOCKED_STS)
 191                 dev_err(arizona->dev, "FX core overclocked\n");
 192         if (val[0] & ARIZONA_DAC_SYS_OVERCLOCKED_STS)
 193                 dev_err(arizona->dev, "DAC SYS overclocked\n");
 194         if (val[0] & ARIZONA_DAC_WARP_OVERCLOCKED_STS)
 195                 dev_err(arizona->dev, "DAC WARP overclocked\n");
 196         if (val[0] & ARIZONA_ADC_OVERCLOCKED_STS)
 197                 dev_err(arizona->dev, "ADC overclocked\n");
 198         if (val[0] & ARIZONA_MIXER_OVERCLOCKED_STS)
 199                 dev_err(arizona->dev, "Mixer overclocked\n");
 200         if (val[0] & ARIZONA_AIF3_SYNC_OVERCLOCKED_STS)
 201                 dev_err(arizona->dev, "AIF3 overclocked\n");
 202         if (val[0] & ARIZONA_AIF2_SYNC_OVERCLOCKED_STS)
 203                 dev_err(arizona->dev, "AIF2 overclocked\n");
 204         if (val[0] & ARIZONA_AIF1_SYNC_OVERCLOCKED_STS)
 205                 dev_err(arizona->dev, "AIF1 overclocked\n");
 206         if (val[0] & ARIZONA_PAD_CTRL_OVERCLOCKED_STS)
 207                 dev_err(arizona->dev, "Pad control overclocked\n");
 208
 209         if (val[1] & ARIZONA_SLIMBUS_SUBSYS_OVERCLOCKED_STS)
 210                 dev_err(arizona->dev, "Slimbus subsystem overclocked\n");
 211         if (val[1] & ARIZONA_SLIMBUS_ASYNC_OVERCLOCKED_STS)
 212                 dev_err(arizona->dev, "Slimbus async overclocked\n");
 213         if (val[1] & ARIZONA_SLIMBUS_SYNC_OVERCLOCKED_STS)
 214                 dev_err(arizona->dev, "Slimbus sync overclocked\n");
 215         if (val[1] & ARIZONA_ASRC_ASYNC_SYS_OVERCLOCKED_STS)
 216                 dev_err(arizona->dev, "ASRC async system overclocked\n");
 217         if (val[1] & ARIZONA_ASRC_ASYNC_WARP_OVERCLOCKED_STS)
 218                 dev_err(arizona->dev, "ASRC async WARP overclocked\n");
 219         if (val[1] & ARIZONA_ASRC_SYNC_SYS_OVERCLOCKED_STS)
 220                 dev_err(arizona->dev, "ASRC sync system overclocked\n");
 221         if (val[1] & ARIZONA_ASRC_SYNC_WARP_OVERCLOCKED_STS)
 222                 dev_err(arizona->dev, "ASRC sync WARP overclocked\n");
 223         if (val[1] & ARIZONA_ADSP2_1_OVERCLOCKED_STS)
 224                 dev_err(arizona->dev, "DSP1 overclocked\n");
 225         if (val[1] & ARIZONA_ISRC3_OVERCLOCKED_STS)
 226                 dev_err(arizona->dev, "ISRC3 overclocked\n");
 227         if (val[1] & ARIZONA_ISRC2_OVERCLOCKED_STS)
 228                 dev_err(arizona->dev, "ISRC2 overclocked\n");
 229         if (val[1] & ARIZONA_ISRC1_OVERCLOCKED_STS)
 230                 dev_err(arizona->dev, "ISRC1 overclocked\n");
 231
 232         if (val[2] & ARIZONA_SPDIF_OVERCLOCKED_STS)
 233                 dev_err(arizona->dev, "SPDIF overclocked\n");
 234
 235         return IRQ_HANDLED;
 236 }
 237
 238 #define ARIZONA_REG_POLL_DELAY_US 7500
 239
 240 static inline bool arizona_poll_reg_delay(ktime_t timeout)
 241 {
 242         if (ktime_compare(ktime_get(), timeout) > 0)
 243                 return false;
 244
 245         usleep_range(ARIZONA_REG_POLL_DELAY_US / 2, ARIZONA_REG_POLL_DELAY_US);
 246
 247         return true;
 248 }
 249
 250 static int arizona_poll_reg(struct arizona *arizona,
 251                             int timeout_ms, unsigned int reg,
 252                             unsigned int mask, unsigned int target)
 253 {
 254         ktime_t timeout = ktime_add_us(ktime_get(), timeout_ms * USEC_PER_MSEC);
 255         unsigned int val = 0;
 256         int ret;
 257
 258         do {
 259                 ret = regmap_read(arizona->regmap, reg, &val);
 260
 261                 if ((val & mask) == target)
 262                         return 0;
 263         } while (arizona_poll_reg_delay(timeout));
 264
 265         if (ret) {
 266                 dev_err(arizona->dev, "Failed polling reg 0x%x: %d\n",
 267                         reg, ret);
 268                 return ret;
 269         }
 270
 271         dev_err(arizona->dev, "Polling reg 0x%x timed out: %x\n", reg, val);
 272         return -ETIMEDOUT;
 273 }
 274
 275 static int arizona_wait_for_boot(struct arizona *arizona)
 276 {
 277         int ret;
 278
 279         /*
 280          * We can't use an interrupt as we need to runtime resume to do so,
 281          * we won't race with the interrupt handler as it'll be blocked on
 282          * runtime resume.
 283          */
 284         ret = arizona_poll_reg(arizona, 30, ARIZONA_INTERRUPT_RAW_STATUS_5,
 285                                ARIZONA_BOOT_DONE_STS, ARIZONA_BOOT_DONE_STS);
 286
 287         if (!ret)
 288                 regmap_write(arizona->regmap, ARIZONA_INTERRUPT_STATUS_5,
 289                              ARIZONA_BOOT_DONE_STS);
 290
 291         pm_runtime_mark_last_busy(arizona->dev);
 292
 293         return ret;
 294 }
 295
 296 static inline void arizona_enable_reset(struct arizona *arizona)
 297 {
 298         if (arizona->pdata.reset)
 299                 gpiod_set_raw_value_cansleep(arizona->pdata.reset, 0);
 300 }
 301
 302 static void arizona_disable_reset(struct arizona *arizona)
 303 {
 304         if (arizona->pdata.reset) {
 305                 switch (arizona->type) {
 306                 case WM5110:
 307                 case WM8280:
 308                         /* Meet requirements for minimum reset duration */
 309                         usleep_range(5000, 10000);
 310                         break;
 311                 default:
 312                         break;
 313                 }
 314
 315                 gpiod_set_raw_value_cansleep(arizona->pdata.reset, 1);
 316                 usleep_range(1000, 5000);
 317         }
 318 }
 319
 320 struct arizona_sysclk_state {
 321         unsigned int fll;
 322         unsigned int sysclk;
 323 };
 324
 325 static int arizona_enable_freerun_sysclk(struct arizona *arizona,
 326                                          struct arizona_sysclk_state *state)
 327 {
 328         int ret, err;
 329
 330         /* Cache existing FLL and SYSCLK settings */
 331         ret = regmap_read(arizona->regmap, ARIZONA_FLL1_CONTROL_1, &state->fll);
 332         if (ret) {
 333                 dev_err(arizona->dev, "Failed to cache FLL settings: %d\n",
 334                         ret);
 335                 return ret;
 336         }
 337         ret = regmap_read(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1,
 338                           &state->sysclk);
 339         if (ret) {
 340                 dev_err(arizona->dev, "Failed to cache SYSCLK settings: %d\n",
 341                         ret);
 342                 return ret;
 343         }
 344
 345         /* Start up SYSCLK using the FLL in free running mode */
 346         ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1,
 347                         ARIZONA_FLL1_ENA | ARIZONA_FLL1_FREERUN);
 348         if (ret) {
 349                 dev_err(arizona->dev,
 350                         "Failed to start FLL in freerunning mode: %d\n",
 351                         ret);
 352                 return ret;
 353         }
 354         ret = arizona_poll_reg(arizona, 180, ARIZONA_INTERRUPT_RAW_STATUS_5,
 355                                ARIZONA_FLL1_CLOCK_OK_STS,
 356                                ARIZONA_FLL1_CLOCK_OK_STS);
 357         if (ret)
 358                 goto err_fll;
 359
 360         ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 0x0144);
 361         if (ret) {
 362                 dev_err(arizona->dev, "Failed to start SYSCLK: %d\n", ret);
 363                 goto err_fll;
 364         }
 365
 366         return 0;
 367
 368 err_fll:
 369         err = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll);
 370         if (err)
 371                 dev_err(arizona->dev,
 372                         "Failed to re-apply old FLL settings: %d\n", err);
 373
 374         return ret;
 375 }
 376
 377 static int arizona_disable_freerun_sysclk(struct arizona *arizona,
 378                                           struct arizona_sysclk_state *state)
 379 {
 380         int ret;
 381
 382         ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1,
 383                            state->sysclk);
 384         if (ret) {
 385                 dev_err(arizona->dev,
 386                         "Failed to re-apply old SYSCLK settings: %d\n", ret);
 387                 return ret;
 388         }
 389
 390         ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll);
 391         if (ret) {
 392                 dev_err(arizona->dev,
 393                         "Failed to re-apply old FLL settings: %d\n", ret);
 394                 return ret;
 395         }
 396
 397         return 0;
 398 }
 399
 400 static int wm5102_apply_hardware_patch(struct arizona *arizona)
 401 {
 402         struct arizona_sysclk_state state;
 403         int err, ret;
 404
 405         ret = arizona_enable_freerun_sysclk(arizona, &state);
 406         if (ret)
 407                 return ret;
 408
 409         /* Start the write sequencer and wait for it to finish */
 410         ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0,
 411                            ARIZONA_WSEQ_ENA | ARIZONA_WSEQ_START | 160);
 412         if (ret) {
 413                 dev_err(arizona->dev, "Failed to start write sequencer: %d\n",
 414                         ret);
 415                 goto err;
 416         }
 417
 418         ret = arizona_poll_reg(arizona, 30, ARIZONA_WRITE_SEQUENCER_CTRL_1,
 419                                ARIZONA_WSEQ_BUSY, 0);
 420         if (ret)
 421                 regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0,
 422                              ARIZONA_WSEQ_ABORT);
 423
 424 err:
 425         err = arizona_disable_freerun_sysclk(arizona, &state);
 426
 427         return ret ?: err;
 428 }
 429
 430 /*
 431  * Register patch to some of the CODECs internal write sequences
 432  * to ensure a clean exit from the low power sleep state.
 433  */
 434 static const struct reg_sequence wm5110_sleep_patch[] = {
 435         { 0x337A, 0xC100 },
 436         { 0x337B, 0x0041 },
 437         { 0x3300, 0xA210 },
 438         { 0x3301, 0x050C },
 439 };
 440
 441 static int wm5110_apply_sleep_patch(struct arizona *arizona)
 442 {
 443         struct arizona_sysclk_state state;
 444         int err, ret;
 445
 446         ret = arizona_enable_freerun_sysclk(arizona, &state);
 447         if (ret)
 448                 return ret;
 449
 450         ret = regmap_multi_reg_write_bypassed(arizona->regmap,
 451                                               wm5110_sleep_patch,
 452                                               ARRAY_SIZE(wm5110_sleep_patch));
 453
 454         err = arizona_disable_freerun_sysclk(arizona, &state);
 455
 456         return ret ?: err;
 457 }
 458
 459 static int wm5102_clear_write_sequencer(struct arizona *arizona)
 460 {
 461         int ret;
 462
 463         ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_3,
 464                            0x0);
 465         if (ret) {
 466                 dev_err(arizona->dev,
 467                         "Failed to clear write sequencer state: %d\n", ret);
 468                 return ret;
 469         }
 470
 471         arizona_enable_reset(arizona);
 472         regulator_disable(arizona->dcvdd);
 473
 474         msleep(20);
 475
 476         ret = regulator_enable(arizona->dcvdd);
 477         if (ret) {
 478                 dev_err(arizona->dev, "Failed to re-enable DCVDD: %d\n", ret);
 479                 return ret;
 480         }
 481         arizona_disable_reset(arizona);
 482
 483         return 0;
 484 }
 485
 486 #ifdef CONFIG_PM
 487 static int arizona_isolate_dcvdd(struct arizona *arizona)
 488 {
 489         int ret;
 490
 491         ret = regmap_update_bits(arizona->regmap,
 492                                  ARIZONA_ISOLATION_CONTROL,
 493                                  ARIZONA_ISOLATE_DCVDD1,
 494                                  ARIZONA_ISOLATE_DCVDD1);
 495         if (ret != 0)
 496                 dev_err(arizona->dev, "Failed to isolate DCVDD: %d\n", ret);
 497
 498         return ret;
 499 }
 500
 501 static int arizona_connect_dcvdd(struct arizona *arizona)
 502 {
 503         int ret;
 504
 505         ret = regmap_update_bits(arizona->regmap,
 506                                  ARIZONA_ISOLATION_CONTROL,
 507                                  ARIZONA_ISOLATE_DCVDD1, 0);
 508         if (ret != 0)
 509                 dev_err(arizona->dev, "Failed to connect DCVDD: %d\n", ret);
 510
 511         return ret;
 512 }
 513
 514 static int arizona_is_jack_det_active(struct arizona *arizona)
 515 {
 516         unsigned int val;
 517         int ret;
 518
 519         ret = regmap_read(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, &val);
 520         if (ret) {
 521                 dev_err(arizona->dev,
 522                         "Failed to check jack det status: %d\n", ret);
 523                 return ret;
 524         } else if (val & ARIZONA_JD1_ENA) {
 525                 return 1;
 526         } else {
 527                 return 0;
 528         }
 529 }
 530
 531 static int arizona_runtime_resume(struct device *dev)
 532 {
 533         struct arizona *arizona = dev_get_drvdata(dev);
 534         int ret;
 535
 536         dev_dbg(arizona->dev, "Leaving AoD mode\n");
 537
 538         if (arizona->has_fully_powered_off) {
 539                 dev_dbg(arizona->dev, "Re-enabling core supplies\n");
 540
 541                 ret = regulator_bulk_enable(arizona->num_core_supplies,
 542                                             arizona->core_supplies);
 543                 if (ret) {
 544                         dev_err(dev, "Failed to enable core supplies: %d\n",
 545                                 ret);
 546                         return ret;
 547                 }
 548         }
 549
 550         ret = regulator_enable(arizona->dcvdd);
 551         if (ret != 0) {
 552                 dev_err(arizona->dev, "Failed to enable DCVDD: %d\n", ret);
 553                 if (arizona->has_fully_powered_off)
 554                         regulator_bulk_disable(arizona->num_core_supplies,
 555                                                arizona->core_supplies);
 556                 return ret;
 557         }
 558
 559         if (arizona->has_fully_powered_off) {
 560                 arizona_disable_reset(arizona);
 561                 enable_irq(arizona->irq);
 562                 arizona->has_fully_powered_off = false;
 563         }
 564
 565         regcache_cache_only(arizona->regmap, false);
 566
 567         switch (arizona->type) {
 568         case WM5102:
 569                 if (arizona->external_dcvdd) {
 570                         ret = arizona_connect_dcvdd(arizona);
 571                         if (ret != 0)
 572                                 goto err;
 573                 }
 574
 575                 ret = wm5102_patch(arizona);
 576                 if (ret != 0) {
 577                         dev_err(arizona->dev, "Failed to apply patch: %d\n",
 578                                 ret);
 579                         goto err;
 580                 }
 581
 582                 ret = wm5102_apply_hardware_patch(arizona);
 583                 if (ret) {
 584                         dev_err(arizona->dev,
 585                                 "Failed to apply hardware patch: %d\n",
 586                                 ret);
 587                         goto err;
 588                 }
 589                 break;
 590         case WM5110:
 591         case WM8280:
 592                 ret = arizona_wait_for_boot(arizona);
 593                 if (ret)
 594                         goto err;
 595
 596                 if (arizona->external_dcvdd) {
 597                         ret = arizona_connect_dcvdd(arizona);
 598                         if (ret != 0)
 599                                 goto err;
 600                 } else {
 601                         /*
 602                          * As this is only called for the internal regulator
 603                          * (where we know voltage ranges available) it is ok
 604                          * to request an exact range.
 605                          */
 606                         ret = regulator_set_voltage(arizona->dcvdd,
 607                                                     1200000, 1200000);
 608                         if (ret < 0) {
 609                                 dev_err(arizona->dev,
 610                                         "Failed to set resume voltage: %d\n",
 611                                         ret);
 612                                 goto err;
 613                         }
 614                 }
 615
 616                 ret = wm5110_apply_sleep_patch(arizona);
 617                 if (ret) {
 618                         dev_err(arizona->dev,
 619                                 "Failed to re-apply sleep patch: %d\n",
 620                                 ret);
 621                         goto err;
 622                 }
 623                 break;
 624         case WM1831:
 625         case CS47L24:
 626                 ret = arizona_wait_for_boot(arizona);
 627                 if (ret != 0)
 628                         goto err;
 629                 break;
 630         default:
 631                 ret = arizona_wait_for_boot(arizona);
 632                 if (ret != 0)
 633                         goto err;
 634
 635                 if (arizona->external_dcvdd) {
 636                         ret = arizona_connect_dcvdd(arizona);
 637                         if (ret != 0)
 638                                 goto err;
 639                 }
 640                 break;
 641         }
 642
 643         ret = regcache_sync(arizona->regmap);
 644         if (ret != 0) {
 645                 dev_err(arizona->dev, "Failed to restore register cache\n");
 646                 goto err;
 647         }
 648
 649         return 0;
 650
 651 err:
 652         regcache_cache_only(arizona->regmap, true);
 653         regulator_disable(arizona->dcvdd);
 654         return ret;
 655 }
 656
 657 static int arizona_runtime_suspend(struct device *dev)
 658 {
 659         struct arizona *arizona = dev_get_drvdata(dev);
 660         int jd_active = 0;
 661         int ret;
 662
 663         dev_dbg(arizona->dev, "Entering AoD mode\n");
 664
 665         switch (arizona->type) {
 666         case WM5110:
 667         case WM8280:
 668                 jd_active = arizona_is_jack_det_active(arizona);
 669                 if (jd_active < 0)
 670                         return jd_active;
 671
 672                 if (arizona->external_dcvdd) {
 673                         ret = arizona_isolate_dcvdd(arizona);
 674                         if (ret != 0)
 675                                 return ret;
 676                 } else {
 677                         /*
 678                          * As this is only called for the internal regulator
 679                          * (where we know voltage ranges available) it is ok
 680                          * to request an exact range.
 681                          */
 682                         ret = regulator_set_voltage(arizona->dcvdd,
 683                                                     1175000, 1175000);
 684                         if (ret < 0) {
 685                                 dev_err(arizona->dev,
 686                                         "Failed to set suspend voltage: %d\n",
 687                                         ret);
 688                                 return ret;
 689                         }
 690                 }
 691                 break;
 692         case WM5102:
 693                 jd_active = arizona_is_jack_det_active(arizona);
 694                 if (jd_active < 0)
 695                         return jd_active;
 696
 697                 if (arizona->external_dcvdd) {
 698                         ret = arizona_isolate_dcvdd(arizona);
 699                         if (ret != 0)
 700                                 return ret;
 701                 }
 702
 703                 if (!jd_active) {
 704                         ret = regmap_write(arizona->regmap,
 705                                            ARIZONA_WRITE_SEQUENCER_CTRL_3, 0x0);
 706                         if (ret) {
 707                                 dev_err(arizona->dev,
 708                                         "Failed to clear write sequencer: %d\n",
 709                                         ret);
 710                                 return ret;
 711                         }
 712                 }
 713                 break;
 714         case WM1831:
 715         case CS47L24:
 716                 break;
 717         default:
 718                 jd_active = arizona_is_jack_det_active(arizona);
 719                 if (jd_active < 0)
 720                         return jd_active;
 721
 722                 if (arizona->external_dcvdd) {
 723                         ret = arizona_isolate_dcvdd(arizona);
 724                         if (ret != 0)
 725                                 return ret;
 726                 }
 727                 break;
 728         }
 729
 730         regcache_cache_only(arizona->regmap, true);
 731         regcache_mark_dirty(arizona->regmap);
 732         regulator_disable(arizona->dcvdd);
 733
 734         /* Allow us to completely power down if no jack detection */
 735         if (!jd_active) {
 736                 dev_dbg(arizona->dev, "Fully powering off\n");
 737
 738                 arizona->has_fully_powered_off = true;
 739
 740                 disable_irq_nosync(arizona->irq);
 741                 arizona_enable_reset(arizona);
 742                 regulator_bulk_disable(arizona->num_core_supplies,
 743                                        arizona->core_supplies);
 744         }
 745
 746         return 0;
 747 }
 748 #endif
 749
 750 #ifdef CONFIG_PM_SLEEP
 751 static int arizona_suspend(struct device *dev)
 752 {
 753         struct arizona *arizona = dev_get_drvdata(dev);
 754
 755         dev_dbg(arizona->dev, "Suspend, disabling IRQ\n");
 756         disable_irq(arizona->irq);
 757
 758         return 0;
 759 }
 760
 761 static int arizona_suspend_noirq(struct device *dev)
 762 {
 763         struct arizona *arizona = dev_get_drvdata(dev);
 764
 765         dev_dbg(arizona->dev, "Late suspend, reenabling IRQ\n");
 766         enable_irq(arizona->irq);
 767
 768         return 0;
 769 }
 770
 771 static int arizona_resume_noirq(struct device *dev)
 772 {
 773         struct arizona *arizona = dev_get_drvdata(dev);
 774
 775         dev_dbg(arizona->dev, "Early resume, disabling IRQ\n");
 776         disable_irq(arizona->irq);
 777
 778         return 0;
 779 }
 780
 781 static int arizona_resume(struct device *dev)
 782 {
 783         struct arizona *arizona = dev_get_drvdata(dev);
 784
 785         dev_dbg(arizona->dev, "Resume, reenabling IRQ\n");
 786         enable_irq(arizona->irq);
 787
 788         return 0;
 789 }
 790 #endif
 791
 792 const struct dev_pm_ops arizona_pm_ops = {
 793         SET_RUNTIME_PM_OPS(arizona_runtime_suspend,
 794                            arizona_runtime_resume,
 795                            NULL)
 796         SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend, arizona_resume)
 797         SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(arizona_suspend_noirq,
 798                                       arizona_resume_noirq)
 799 };
 800 EXPORT_SYMBOL_GPL(arizona_pm_ops);
 801
 802 #ifdef CONFIG_OF
 803 unsigned long arizona_of_get_type(struct device *dev)
 804 {
 805         const struct of_device_id *id = of_match_device(arizona_of_match, dev);
 806
 807         if (id)
 808                 return (unsigned long)id->data;
 809         else
 810                 return 0;
 811 }
 812 EXPORT_SYMBOL_GPL(arizona_of_get_type);
 813
 814 static int arizona_of_get_core_pdata(struct arizona *arizona)
 815 {
 816         struct arizona_pdata *pdata = &arizona->pdata;
 817         int ret, i;
 818
 819         /* Handle old non-standard DT binding */
 820         pdata->reset = devm_gpiod_get_from_of_node(arizona->dev,
 821                                                    arizona->dev->of_node,
 822                                                    "wlf,reset", 0,
 823                                                    GPIOD_OUT_LOW,
 824                                                    "arizona /RESET");
 825         if (IS_ERR(pdata->reset)) {
 826                 ret = PTR_ERR(pdata->reset);
 827
 828                 /*
 829                  * Reset missing will be caught when other binding is read
 830                  * but all other errors imply this binding is in use but has
 831                  * encountered a problem so should be handled.
 832                  */
 833                 if (ret == -EPROBE_DEFER)
 834                         return ret;
 835                 else if (ret != -ENOENT && ret != -ENOSYS)
 836                         dev_err(arizona->dev, "Reset GPIO malformed: %d\n",
 837                                 ret);
 838
 839                 pdata->reset = NULL;
 840         }
 841
 842         ret = of_property_read_u32_array(arizona->dev->of_node,
 843                                          "wlf,gpio-defaults",
 844                                          pdata->gpio_defaults,
 845                                          ARRAY_SIZE(pdata->gpio_defaults));
 846         if (ret >= 0) {
 847                 /*
 848                  * All values are literal except out of range values
 849                  * which are chip default, translate into platform
 850                  * data which uses 0 as chip default and out of range
 851                  * as zero.
 852                  */
 853                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 854                         if (pdata->gpio_defaults[i] > 0xffff)
 855                                 pdata->gpio_defaults[i] = 0;
 856                         else if (pdata->gpio_defaults[i] == 0)
 857                                 pdata->gpio_defaults[i] = 0x10000;
 858                 }
 859         } else {
 860                 dev_err(arizona->dev, "Failed to parse GPIO defaults: %d\n",
 861                         ret);
 862         }
 863
 864         return 0;
 865 }
 866
 867 const struct of_device_id arizona_of_match[] = {
 868         { .compatible = "wlf,wm5102", .data = (void *)WM5102 },
 869         { .compatible = "wlf,wm5110", .data = (void *)WM5110 },
 870         { .compatible = "wlf,wm8280", .data = (void *)WM8280 },
 871         { .compatible = "wlf,wm8997", .data = (void *)WM8997 },
 872         { .compatible = "wlf,wm8998", .data = (void *)WM8998 },
 873         { .compatible = "wlf,wm1814", .data = (void *)WM1814 },
 874         { .compatible = "wlf,wm1831", .data = (void *)WM1831 },
 875         { .compatible = "cirrus,cs47l24", .data = (void *)CS47L24 },
 876         {},
 877 };
 878 EXPORT_SYMBOL_GPL(arizona_of_match);
 879 #else
 880 static inline int arizona_of_get_core_pdata(struct arizona *arizona)
 881 {
 882         return 0;
 883 }
 884 #endif
 885
 886 static const struct mfd_cell early_devs[] = {
 887         { .name = "arizona-ldo1" },
 888 };
 889
 890 static const char * const wm5102_supplies[] = {
 891         "MICVDD",
 892         "DBVDD2",
 893         "DBVDD3",
 894         "CPVDD",
 895         "SPKVDDL",
 896         "SPKVDDR",
 897 };
 898
 899 static const struct mfd_cell wm5102_devs[] = {
 900         { .name = "arizona-micsupp" },
 901         { .name = "arizona-gpio" },
 902         {
 903                 .name = "arizona-extcon",
 904                 .parent_supplies = wm5102_supplies,
 905                 .num_parent_supplies = 1, /* We only need MICVDD */
 906         },
 907         { .name = "arizona-haptics" },
 908         { .name = "arizona-pwm" },
 909         {
 910                 .name = "wm5102-codec",
 911                 .parent_supplies = wm5102_supplies,
 912                 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
 913         },
 914 };
 915
 916 static const struct mfd_cell wm5110_devs[] = {
 917         { .name = "arizona-micsupp" },
 918         { .name = "arizona-gpio" },
 919         {
 920                 .name = "arizona-extcon",
 921                 .parent_supplies = wm5102_supplies,
 922                 .num_parent_supplies = 1, /* We only need MICVDD */
 923         },
 924         { .name = "arizona-haptics" },
 925         { .name = "arizona-pwm" },
 926         {
 927                 .name = "wm5110-codec",
 928                 .parent_supplies = wm5102_supplies,
 929                 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
 930         },
 931 };
 932
 933 static const char * const cs47l24_supplies[] = {
 934         "MICVDD",
 935         "CPVDD",
 936         "SPKVDD",
 937 };
 938
 939 static const struct mfd_cell cs47l24_devs[] = {
 940         { .name = "arizona-gpio" },
 941         { .name = "arizona-haptics" },
 942         { .name = "arizona-pwm" },
 943         {
 944                 .name = "cs47l24-codec",
 945                 .parent_supplies = cs47l24_supplies,
 946                 .num_parent_supplies = ARRAY_SIZE(cs47l24_supplies),
 947         },
 948 };
 949
 950 static const char * const wm8997_supplies[] = {
 951         "MICVDD",
 952         "DBVDD2",
 953         "CPVDD",
 954         "SPKVDD",
 955 };
 956
 957 static const struct mfd_cell wm8997_devs[] = {
 958         { .name = "arizona-micsupp" },
 959         { .name = "arizona-gpio" },
 960         {
 961                 .name = "arizona-extcon",
 962                 .parent_supplies = wm8997_supplies,
 963                 .num_parent_supplies = 1, /* We only need MICVDD */
 964         },
 965         { .name = "arizona-haptics" },
 966         { .name = "arizona-pwm" },
 967         {
 968                 .name = "wm8997-codec",
 969                 .parent_supplies = wm8997_supplies,
 970                 .num_parent_supplies = ARRAY_SIZE(wm8997_supplies),
 971         },
 972 };
 973
 974 static const struct mfd_cell wm8998_devs[] = {
 975         { .name = "arizona-micsupp" },
 976         { .name = "arizona-gpio" },
 977         {
 978                 .name = "arizona-extcon",
 979                 .parent_supplies = wm5102_supplies,
 980                 .num_parent_supplies = 1, /* We only need MICVDD */
 981         },
 982         { .name = "arizona-haptics" },
 983         { .name = "arizona-pwm" },
 984         {
 985                 .name = "wm8998-codec",
 986                 .parent_supplies = wm5102_supplies,
 987                 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
 988         },
 989 };
 990
 991 int arizona_dev_init(struct arizona *arizona)
 992 {
 993         static const char * const mclk_name[] = { "mclk1", "mclk2" };
 994         struct device *dev = arizona->dev;
 995         const char *type_name = NULL;
 996         unsigned int reg, val;
 997         int (*apply_patch)(struct arizona *) = NULL;
 998         const struct mfd_cell *subdevs = NULL;
 999         int n_subdevs, ret, i;
1000
1001         dev_set_drvdata(arizona->dev, arizona);
1002         mutex_init(&arizona->clk_lock);
1003
1004         if (dev_get_platdata(arizona->dev)) {
1005                 memcpy(&arizona->pdata, dev_get_platdata(arizona->dev),
1006                        sizeof(arizona->pdata));
1007         } else {
1008                 ret = arizona_of_get_core_pdata(arizona);
1009                 if (ret < 0)
1010                         return ret;
1011         }
1012
1013         BUILD_BUG_ON(ARRAY_SIZE(arizona->mclk) != ARRAY_SIZE(mclk_name));
1014         for (i = 0; i < ARRAY_SIZE(arizona->mclk); i++) {
1015                 arizona->mclk[i] = devm_clk_get(arizona->dev, mclk_name[i]);
1016                 if (IS_ERR(arizona->mclk[i])) {
1017                         dev_info(arizona->dev, "Failed to get %s: %ld\n",
1018                                  mclk_name[i], PTR_ERR(arizona->mclk[i]));
1019                         arizona->mclk[i] = NULL;
1020                 }
1021         }
1022
1023         regcache_cache_only(arizona->regmap, true);
1024
1025         switch (arizona->type) {
1026         case WM5102:
1027         case WM5110:
1028         case WM8280:
1029         case WM8997:
1030         case WM8998:
1031         case WM1814:
1032         case WM1831:
1033         case CS47L24:
1034                 for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++)
1035                         arizona->core_supplies[i].supply
1036                                 = wm5102_core_supplies[i];
1037                 arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies);
1038                 break;
1039         default:
1040                 dev_err(arizona->dev, "Unknown device type %d\n",
1041                         arizona->type);
1042                 return -ENODEV;
1043         }
1044
1045         /* Mark DCVDD as external, LDO1 driver will clear if internal */
1046         arizona->external_dcvdd = true;
1047
1048         switch (arizona->type) {
1049         case WM1831:
1050         case CS47L24:
1051                 break; /* No LDO1 regulator */
1052         default:
1053                 ret = mfd_add_devices(arizona->dev, -1, early_devs,
1054                                       ARRAY_SIZE(early_devs), NULL, 0, NULL);
1055                 if (ret != 0) {
1056                         dev_err(dev, "Failed to add early children: %d\n", ret);
1057                         return ret;
1058                 }
1059                 break;
1060         }
1061
1062         ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies,
1063                                       arizona->core_supplies);
1064         if (ret != 0) {
1065                 dev_err(dev, "Failed to request core supplies: %d\n",
1066                         ret);
1067                 goto err_early;
1068         }
1069
1070         /**
1071          * Don't use devres here because the only device we have to get
1072          * against is the MFD device and DCVDD will likely be supplied by
1073          * one of its children. Meaning that the regulator will be
1074          * destroyed by the time devres calls regulator put.
1075          */
1076         arizona->dcvdd = regulator_get(arizona->dev, "DCVDD");
1077         if (IS_ERR(arizona->dcvdd)) {
1078                 ret = PTR_ERR(arizona->dcvdd);
1079                 dev_err(dev, "Failed to request DCVDD: %d\n", ret);
1080                 goto err_early;
1081         }
1082
1083         if (!arizona->pdata.reset) {
1084                 /* Start out with /RESET low to put the chip into reset */
1085                 arizona->pdata.reset = devm_gpiod_get(arizona->dev, "reset",
1086                                                       GPIOD_OUT_LOW);
1087                 if (IS_ERR(arizona->pdata.reset)) {
1088                         ret = PTR_ERR(arizona->pdata.reset);
1089                         if (ret == -EPROBE_DEFER)
1090                                 goto err_dcvdd;
1091
1092                         dev_err(arizona->dev,
1093                                 "Reset GPIO missing/malformed: %d\n", ret);
1094
1095                         arizona->pdata.reset = NULL;
1096                 }
1097         }
1098
1099         ret = regulator_bulk_enable(arizona->num_core_supplies,
1100                                     arizona->core_supplies);
1101         if (ret != 0) {
1102                 dev_err(dev, "Failed to enable core supplies: %d\n",
1103                         ret);
1104                 goto err_dcvdd;
1105         }
1106
1107         ret = regulator_enable(arizona->dcvdd);
1108         if (ret != 0) {
1109                 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
1110                 goto err_enable;
1111         }
1112
1113         arizona_disable_reset(arizona);
1114
1115         regcache_cache_only(arizona->regmap, false);
1116
1117         /* Verify that this is a chip we know about */
1118         ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1119         if (ret != 0) {
1120                 dev_err(dev, "Failed to read ID register: %d\n", ret);
1121                 goto err_reset;
1122         }
1123
1124         switch (reg) {
1125         case 0x5102:
1126         case 0x5110:
1127         case 0x6349:
1128         case 0x6363:
1129         case 0x8997:
1130                 break;
1131         default:
1132                 dev_err(arizona->dev, "Unknown device ID: %x\n", reg);
1133                 ret = -ENODEV;
1134                 goto err_reset;
1135         }
1136
1137         /* If we have a /RESET GPIO we'll already be reset */
1138         if (!arizona->pdata.reset) {
1139                 ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0);
1140                 if (ret != 0) {
1141                         dev_err(dev, "Failed to reset device: %d\n", ret);
1142                         goto err_reset;
1143                 }
1144
1145                 usleep_range(1000, 5000);
1146         }
1147
1148         /* Ensure device startup is complete */
1149         switch (arizona->type) {
1150         case WM5102:
1151                 ret = regmap_read(arizona->regmap,
1152                                   ARIZONA_WRITE_SEQUENCER_CTRL_3, &val);
1153                 if (ret) {
1154                         dev_err(dev,
1155                                 "Failed to check write sequencer state: %d\n",
1156                                 ret);
1157                 } else if (val & 0x01) {
1158                         ret = wm5102_clear_write_sequencer(arizona);
1159                         if (ret)
1160                                 return ret;
1161                 }
1162                 break;
1163         default:
1164                 break;
1165         }
1166
1167         ret = arizona_wait_for_boot(arizona);
1168         if (ret) {
1169                 dev_err(arizona->dev, "Device failed initial boot: %d\n", ret);
1170                 goto err_reset;
1171         }
1172
1173         /* Read the device ID information & do device specific stuff */
1174         ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1175         if (ret != 0) {
1176                 dev_err(dev, "Failed to read ID register: %d\n", ret);
1177                 goto err_reset;
1178         }
1179
1180         ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION,
1181                           &arizona->rev);
1182         if (ret != 0) {
1183                 dev_err(dev, "Failed to read revision register: %d\n", ret);
1184                 goto err_reset;
1185         }
1186         arizona->rev &= ARIZONA_DEVICE_REVISION_MASK;
1187
1188         switch (reg) {
1189         case 0x5102:
1190                 if (IS_ENABLED(CONFIG_MFD_WM5102)) {
1191                         type_name = "WM5102";
1192                         if (arizona->type != WM5102) {
1193                                 dev_warn(arizona->dev,
1194                                          "WM5102 registered as %d\n",
1195                                          arizona->type);
1196                                 arizona->type = WM5102;
1197                         }
1198
1199                         apply_patch = wm5102_patch;
1200                         arizona->rev &= 0x7;
1201                         subdevs = wm5102_devs;
1202                         n_subdevs = ARRAY_SIZE(wm5102_devs);
1203                 }
1204                 break;
1205         case 0x5110:
1206                 if (IS_ENABLED(CONFIG_MFD_WM5110)) {
1207                         switch (arizona->type) {
1208                         case WM5110:
1209                                 type_name = "WM5110";
1210                                 break;
1211                         case WM8280:
1212                                 type_name = "WM8280";
1213                                 break;
1214                         default:
1215                                 type_name = "WM5110";
1216                                 dev_warn(arizona->dev,
1217                                          "WM5110 registered as %d\n",
1218                                          arizona->type);
1219                                 arizona->type = WM5110;
1220                                 break;
1221                         }
1222
1223                         apply_patch = wm5110_patch;
1224                         subdevs = wm5110_devs;
1225                         n_subdevs = ARRAY_SIZE(wm5110_devs);
1226                 }
1227                 break;
1228         case 0x6363:
1229                 if (IS_ENABLED(CONFIG_MFD_CS47L24)) {
1230                         switch (arizona->type) {
1231                         case CS47L24:
1232                                 type_name = "CS47L24";
1233                                 break;
1234
1235                         case WM1831:
1236                                 type_name = "WM1831";
1237                                 break;
1238
1239                         default:
1240                                 dev_warn(arizona->dev,
1241                                          "CS47L24 registered as %d\n",
1242                                          arizona->type);
1243                                 arizona->type = CS47L24;
1244                                 break;
1245                         }
1246
1247                         apply_patch = cs47l24_patch;
1248                         subdevs = cs47l24_devs;
1249                         n_subdevs = ARRAY_SIZE(cs47l24_devs);
1250                 }
1251                 break;
1252         case 0x8997:
1253                 if (IS_ENABLED(CONFIG_MFD_WM8997)) {
1254                         type_name = "WM8997";
1255                         if (arizona->type != WM8997) {
1256                                 dev_warn(arizona->dev,
1257                                          "WM8997 registered as %d\n",
1258                                          arizona->type);
1259                                 arizona->type = WM8997;
1260                         }
1261
1262                         apply_patch = wm8997_patch;
1263                         subdevs = wm8997_devs;
1264                         n_subdevs = ARRAY_SIZE(wm8997_devs);
1265                 }
1266                 break;
1267         case 0x6349:
1268                 if (IS_ENABLED(CONFIG_MFD_WM8998)) {
1269                         switch (arizona->type) {
1270                         case WM8998:
1271                                 type_name = "WM8998";
1272                                 break;
1273
1274                         case WM1814:
1275                                 type_name = "WM1814";
1276                                 break;
1277
1278                         default:
1279                                 type_name = "WM8998";
1280                                 dev_warn(arizona->dev,
1281                                          "WM8998 registered as %d\n",
1282                                          arizona->type);
1283                                 arizona->type = WM8998;
1284                         }
1285
1286                         apply_patch = wm8998_patch;
1287                         subdevs = wm8998_devs;
1288                         n_subdevs = ARRAY_SIZE(wm8998_devs);
1289                 }
1290                 break;
1291         default:
1292                 dev_err(arizona->dev, "Unknown device ID %x\n", reg);
1293                 ret = -ENODEV;
1294                 goto err_reset;
1295         }
1296
1297         if (!subdevs) {
1298                 dev_err(arizona->dev,
1299                         "No kernel support for device ID %x\n", reg);
1300                 ret = -ENODEV;
1301                 goto err_reset;
1302         }
1303
1304         dev_info(dev, "%s revision %c\n", type_name, arizona->rev + 'A');
1305
1306         if (apply_patch) {
1307                 ret = apply_patch(arizona);
1308                 if (ret != 0) {
1309                         dev_err(arizona->dev, "Failed to apply patch: %d\n",
1310                                 ret);
1311                         goto err_reset;
1312                 }
1313
1314                 switch (arizona->type) {
1315                 case WM5102:
1316                         ret = wm5102_apply_hardware_patch(arizona);
1317                         if (ret) {
1318                                 dev_err(arizona->dev,
1319                                         "Failed to apply hardware patch: %d\n",
1320                                         ret);
1321                                 goto err_reset;
1322                         }
1323                         break;
1324                 case WM5110:
1325                 case WM8280:
1326                         ret = wm5110_apply_sleep_patch(arizona);
1327                         if (ret) {
1328                                 dev_err(arizona->dev,
1329                                         "Failed to apply sleep patch: %d\n",
1330                                         ret);
1331                                 goto err_reset;
1332                         }
1333                         break;
1334                 default:
1335                         break;
1336                 }
1337         }
1338
1339         for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) {
1340                 if (!arizona->pdata.gpio_defaults[i])
1341                         continue;
1342
1343                 regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i,
1344                              arizona->pdata.gpio_defaults[i]);
1345         }
1346
1347         /* Chip default */
1348         if (!arizona->pdata.clk32k_src)
1349                 arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2;
1350
1351         switch (arizona->pdata.clk32k_src) {
1352         case ARIZONA_32KZ_MCLK1:
1353         case ARIZONA_32KZ_MCLK2:
1354                 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1355                                    ARIZONA_CLK_32K_SRC_MASK,
1356                                    arizona->pdata.clk32k_src - 1);
1357                 arizona_clk32k_enable(arizona);
1358                 break;
1359         case ARIZONA_32KZ_NONE:
1360                 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1361                                    ARIZONA_CLK_32K_SRC_MASK, 2);
1362                 break;
1363         default:
1364                 dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n",
1365                         arizona->pdata.clk32k_src);
1366                 ret = -EINVAL;
1367                 goto err_reset;
1368         }
1369
1370         for (i = 0; i < ARIZONA_MAX_MICBIAS; i++) {
1371                 if (!arizona->pdata.micbias[i].mV &&
1372                     !arizona->pdata.micbias[i].bypass)
1373                         continue;
1374
1375                 /* Apply default for bypass mode */
1376                 if (!arizona->pdata.micbias[i].mV)
1377                         arizona->pdata.micbias[i].mV = 2800;
1378
1379                 val = (arizona->pdata.micbias[i].mV - 1500) / 100;
1380
1381                 val <<= ARIZONA_MICB1_LVL_SHIFT;
1382
1383                 if (arizona->pdata.micbias[i].ext_cap)
1384                         val |= ARIZONA_MICB1_EXT_CAP;
1385
1386                 if (arizona->pdata.micbias[i].discharge)
1387                         val |= ARIZONA_MICB1_DISCH;
1388
1389                 if (arizona->pdata.micbias[i].soft_start)
1390                         val |= ARIZONA_MICB1_RATE;
1391
1392                 if (arizona->pdata.micbias[i].bypass)
1393                         val |= ARIZONA_MICB1_BYPASS;
1394
1395                 regmap_update_bits(arizona->regmap,
1396                                    ARIZONA_MIC_BIAS_CTRL_1 + i,
1397                                    ARIZONA_MICB1_LVL_MASK |
1398                                    ARIZONA_MICB1_EXT_CAP |
1399                                    ARIZONA_MICB1_DISCH |
1400                                    ARIZONA_MICB1_BYPASS |
1401                                    ARIZONA_MICB1_RATE, val);
1402         }
1403
1404         pm_runtime_set_active(arizona->dev);
1405         pm_runtime_enable(arizona->dev);
1406
1407         /* Set up for interrupts */
1408         ret = arizona_irq_init(arizona);
1409         if (ret != 0)
1410                 goto err_pm;
1411
1412         pm_runtime_set_autosuspend_delay(arizona->dev, 100);
1413         pm_runtime_use_autosuspend(arizona->dev);
1414
1415         arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error",
1416                             arizona_clkgen_err, arizona);
1417         arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked",
1418                             arizona_overclocked, arizona);
1419         arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked",
1420                             arizona_underclocked, arizona);
1421
1422         ret = mfd_add_devices(arizona->dev, PLATFORM_DEVID_NONE,
1423                               subdevs, n_subdevs, NULL, 0, NULL);
1424
1425         if (ret) {
1426                 dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret);
1427                 goto err_irq;
1428         }
1429
1430         return 0;
1431
1432 err_irq:
1433         arizona_irq_exit(arizona);
1434 err_pm:
1435         pm_runtime_disable(arizona->dev);
1436 err_reset:
1437         arizona_enable_reset(arizona);
1438         regulator_disable(arizona->dcvdd);
1439 err_enable:
1440         regulator_bulk_disable(arizona->num_core_supplies,
1441                                arizona->core_supplies);
1442 err_dcvdd:
1443         regulator_put(arizona->dcvdd);
1444 err_early:
1445         mfd_remove_devices(dev);
1446         return ret;
1447 }
1448 EXPORT_SYMBOL_GPL(arizona_dev_init);
1449
1450 int arizona_dev_exit(struct arizona *arizona)
1451 {
1452         disable_irq(arizona->irq);
1453         pm_runtime_disable(arizona->dev);
1454
1455         regulator_disable(arizona->dcvdd);
1456         regulator_put(arizona->dcvdd);
1457
1458         mfd_remove_devices(arizona->dev);
1459         arizona_free_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, arizona);
1460         arizona_free_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, arizona);
1461         arizona_free_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, arizona);
1462         arizona_irq_exit(arizona);
1463         arizona_enable_reset(arizona);
1464
1465         regulator_bulk_disable(arizona->num_core_supplies,
1466                                arizona->core_supplies);
1467         return 0;
1468 }
1469 EXPORT_SYMBOL_GPL(arizona_dev_exit);