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