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