Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Arizona core driver
0004  *
0005  * Copyright 2012 Wolfson Microelectronics plc
0006  *
0007  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
0008  */
0009 
0010 #include <linux/clk.h>
0011 #include <linux/delay.h>
0012 #include <linux/err.h>
0013 #include <linux/gpio/consumer.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/mfd/core.h>
0016 #include <linux/module.h>
0017 #include <linux/of.h>
0018 #include <linux/of_device.h>
0019 #include <linux/pm_runtime.h>
0020 #include <linux/regmap.h>
0021 #include <linux/regulator/consumer.h>
0022 #include <linux/regulator/machine.h>
0023 #include <linux/slab.h>
0024 #include <linux/ktime.h>
0025 #include <linux/platform_device.h>
0026 
0027 #include <linux/mfd/arizona/core.h>
0028 #include <linux/mfd/arizona/registers.h>
0029 
0030 #include "arizona.h"
0031 
0032 static const char * const wm5102_core_supplies[] = {
0033     "AVDD",
0034     "DBVDD1",
0035 };
0036 
0037 int arizona_clk32k_enable(struct arizona *arizona)
0038 {
0039     int ret = 0;
0040 
0041     mutex_lock(&arizona->clk_lock);
0042 
0043     arizona->clk32k_ref++;
0044 
0045     if (arizona->clk32k_ref == 1) {
0046         switch (arizona->pdata.clk32k_src) {
0047         case ARIZONA_32KZ_MCLK1:
0048             ret = pm_runtime_get_sync(arizona->dev);
0049             if (ret != 0)
0050                 goto err_ref;
0051             ret = clk_prepare_enable(arizona->mclk[ARIZONA_MCLK1]);
0052             if (ret != 0) {
0053                 pm_runtime_put_sync(arizona->dev);
0054                 goto err_ref;
0055             }
0056             break;
0057         case ARIZONA_32KZ_MCLK2:
0058             ret = clk_prepare_enable(arizona->mclk[ARIZONA_MCLK2]);
0059             if (ret != 0)
0060                 goto err_ref;
0061             break;
0062         }
0063 
0064         ret = regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
0065                      ARIZONA_CLK_32K_ENA,
0066                      ARIZONA_CLK_32K_ENA);
0067     }
0068 
0069 err_ref:
0070     if (ret != 0)
0071         arizona->clk32k_ref--;
0072 
0073     mutex_unlock(&arizona->clk_lock);
0074 
0075     return ret;
0076 }
0077 EXPORT_SYMBOL_GPL(arizona_clk32k_enable);
0078 
0079 int arizona_clk32k_disable(struct arizona *arizona)
0080 {
0081     mutex_lock(&arizona->clk_lock);
0082 
0083     WARN_ON(arizona->clk32k_ref <= 0);
0084 
0085     arizona->clk32k_ref--;
0086 
0087     if (arizona->clk32k_ref == 0) {
0088         regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
0089                    ARIZONA_CLK_32K_ENA, 0);
0090 
0091         switch (arizona->pdata.clk32k_src) {
0092         case ARIZONA_32KZ_MCLK1:
0093             pm_runtime_put_sync(arizona->dev);
0094             clk_disable_unprepare(arizona->mclk[ARIZONA_MCLK1]);
0095             break;
0096         case ARIZONA_32KZ_MCLK2:
0097             clk_disable_unprepare(arizona->mclk[ARIZONA_MCLK2]);
0098             break;
0099         }
0100     }
0101 
0102     mutex_unlock(&arizona->clk_lock);
0103 
0104     return 0;
0105 }
0106 EXPORT_SYMBOL_GPL(arizona_clk32k_disable);
0107 
0108 static irqreturn_t arizona_clkgen_err(int irq, void *data)
0109 {
0110     struct arizona *arizona = data;
0111 
0112     dev_err(arizona->dev, "CLKGEN error\n");
0113 
0114     return IRQ_HANDLED;
0115 }
0116 
0117 static irqreturn_t arizona_underclocked(int irq, void *data)
0118 {
0119     struct arizona *arizona = data;
0120     unsigned int val;
0121     int ret;
0122 
0123     ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_8,
0124               &val);
0125     if (ret != 0) {
0126         dev_err(arizona->dev, "Failed to read underclock status: %d\n",
0127             ret);
0128         return IRQ_NONE;
0129     }
0130 
0131     if (val & ARIZONA_AIF3_UNDERCLOCKED_STS)
0132         dev_err(arizona->dev, "AIF3 underclocked\n");
0133     if (val & ARIZONA_AIF2_UNDERCLOCKED_STS)
0134         dev_err(arizona->dev, "AIF2 underclocked\n");
0135     if (val & ARIZONA_AIF1_UNDERCLOCKED_STS)
0136         dev_err(arizona->dev, "AIF1 underclocked\n");
0137     if (val & ARIZONA_ISRC3_UNDERCLOCKED_STS)
0138         dev_err(arizona->dev, "ISRC3 underclocked\n");
0139     if (val & ARIZONA_ISRC2_UNDERCLOCKED_STS)
0140         dev_err(arizona->dev, "ISRC2 underclocked\n");
0141     if (val & ARIZONA_ISRC1_UNDERCLOCKED_STS)
0142         dev_err(arizona->dev, "ISRC1 underclocked\n");
0143     if (val & ARIZONA_FX_UNDERCLOCKED_STS)
0144         dev_err(arizona->dev, "FX underclocked\n");
0145     if (val & ARIZONA_ASRC_UNDERCLOCKED_STS)
0146         dev_err(arizona->dev, "ASRC underclocked\n");
0147     if (val & ARIZONA_DAC_UNDERCLOCKED_STS)
0148         dev_err(arizona->dev, "DAC underclocked\n");
0149     if (val & ARIZONA_ADC_UNDERCLOCKED_STS)
0150         dev_err(arizona->dev, "ADC underclocked\n");
0151     if (val & ARIZONA_MIXER_UNDERCLOCKED_STS)
0152         dev_err(arizona->dev, "Mixer dropped sample\n");
0153 
0154     return IRQ_HANDLED;
0155 }
0156 
0157 static irqreturn_t arizona_overclocked(int irq, void *data)
0158 {
0159     struct arizona *arizona = data;
0160     unsigned int val[3];
0161     int ret;
0162 
0163     ret = regmap_bulk_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_6,
0164                    &val[0], 3);
0165     if (ret != 0) {
0166         dev_err(arizona->dev, "Failed to read overclock status: %d\n",
0167             ret);
0168         return IRQ_NONE;
0169     }
0170 
0171     switch (arizona->type) {
0172     case WM8998:
0173     case WM1814:
0174         /* Some bits are shifted on WM8998,
0175          * rearrange to match the standard bit layout
0176          */
0177         val[0] = ((val[0] & 0x60e0) >> 1) |
0178              ((val[0] & 0x1e00) >> 2) |
0179              (val[0] & 0x000f);
0180         break;
0181     default:
0182         break;
0183     }
0184 
0185     if (val[0] & ARIZONA_PWM_OVERCLOCKED_STS)
0186         dev_err(arizona->dev, "PWM overclocked\n");
0187     if (val[0] & ARIZONA_FX_CORE_OVERCLOCKED_STS)
0188         dev_err(arizona->dev, "FX core overclocked\n");
0189     if (val[0] & ARIZONA_DAC_SYS_OVERCLOCKED_STS)
0190         dev_err(arizona->dev, "DAC SYS overclocked\n");
0191     if (val[0] & ARIZONA_DAC_WARP_OVERCLOCKED_STS)
0192         dev_err(arizona->dev, "DAC WARP overclocked\n");
0193     if (val[0] & ARIZONA_ADC_OVERCLOCKED_STS)
0194         dev_err(arizona->dev, "ADC overclocked\n");
0195     if (val[0] & ARIZONA_MIXER_OVERCLOCKED_STS)
0196         dev_err(arizona->dev, "Mixer overclocked\n");
0197     if (val[0] & ARIZONA_AIF3_SYNC_OVERCLOCKED_STS)
0198         dev_err(arizona->dev, "AIF3 overclocked\n");
0199     if (val[0] & ARIZONA_AIF2_SYNC_OVERCLOCKED_STS)
0200         dev_err(arizona->dev, "AIF2 overclocked\n");
0201     if (val[0] & ARIZONA_AIF1_SYNC_OVERCLOCKED_STS)
0202         dev_err(arizona->dev, "AIF1 overclocked\n");
0203     if (val[0] & ARIZONA_PAD_CTRL_OVERCLOCKED_STS)
0204         dev_err(arizona->dev, "Pad control overclocked\n");
0205 
0206     if (val[1] & ARIZONA_SLIMBUS_SUBSYS_OVERCLOCKED_STS)
0207         dev_err(arizona->dev, "Slimbus subsystem overclocked\n");
0208     if (val[1] & ARIZONA_SLIMBUS_ASYNC_OVERCLOCKED_STS)
0209         dev_err(arizona->dev, "Slimbus async overclocked\n");
0210     if (val[1] & ARIZONA_SLIMBUS_SYNC_OVERCLOCKED_STS)
0211         dev_err(arizona->dev, "Slimbus sync overclocked\n");
0212     if (val[1] & ARIZONA_ASRC_ASYNC_SYS_OVERCLOCKED_STS)
0213         dev_err(arizona->dev, "ASRC async system overclocked\n");
0214     if (val[1] & ARIZONA_ASRC_ASYNC_WARP_OVERCLOCKED_STS)
0215         dev_err(arizona->dev, "ASRC async WARP overclocked\n");
0216     if (val[1] & ARIZONA_ASRC_SYNC_SYS_OVERCLOCKED_STS)
0217         dev_err(arizona->dev, "ASRC sync system overclocked\n");
0218     if (val[1] & ARIZONA_ASRC_SYNC_WARP_OVERCLOCKED_STS)
0219         dev_err(arizona->dev, "ASRC sync WARP overclocked\n");
0220     if (val[1] & ARIZONA_ADSP2_1_OVERCLOCKED_STS)
0221         dev_err(arizona->dev, "DSP1 overclocked\n");
0222     if (val[1] & ARIZONA_ISRC3_OVERCLOCKED_STS)
0223         dev_err(arizona->dev, "ISRC3 overclocked\n");
0224     if (val[1] & ARIZONA_ISRC2_OVERCLOCKED_STS)
0225         dev_err(arizona->dev, "ISRC2 overclocked\n");
0226     if (val[1] & ARIZONA_ISRC1_OVERCLOCKED_STS)
0227         dev_err(arizona->dev, "ISRC1 overclocked\n");
0228 
0229     if (val[2] & ARIZONA_SPDIF_OVERCLOCKED_STS)
0230         dev_err(arizona->dev, "SPDIF overclocked\n");
0231 
0232     return IRQ_HANDLED;
0233 }
0234 
0235 #define ARIZONA_REG_POLL_DELAY_US 7500
0236 
0237 static inline bool arizona_poll_reg_delay(ktime_t timeout)
0238 {
0239     if (ktime_compare(ktime_get(), timeout) > 0)
0240         return false;
0241 
0242     usleep_range(ARIZONA_REG_POLL_DELAY_US / 2, ARIZONA_REG_POLL_DELAY_US);
0243 
0244     return true;
0245 }
0246 
0247 static int arizona_poll_reg(struct arizona *arizona,
0248                 int timeout_ms, unsigned int reg,
0249                 unsigned int mask, unsigned int target)
0250 {
0251     ktime_t timeout = ktime_add_us(ktime_get(), timeout_ms * USEC_PER_MSEC);
0252     unsigned int val = 0;
0253     int ret;
0254 
0255     do {
0256         ret = regmap_read(arizona->regmap, reg, &val);
0257 
0258         if ((val & mask) == target)
0259             return 0;
0260     } while (arizona_poll_reg_delay(timeout));
0261 
0262     if (ret) {
0263         dev_err(arizona->dev, "Failed polling reg 0x%x: %d\n",
0264             reg, ret);
0265         return ret;
0266     }
0267 
0268     dev_err(arizona->dev, "Polling reg 0x%x timed out: %x\n", reg, val);
0269     return -ETIMEDOUT;
0270 }
0271 
0272 static int arizona_wait_for_boot(struct arizona *arizona)
0273 {
0274     int ret;
0275 
0276     /*
0277      * We can't use an interrupt as we need to runtime resume to do so,
0278      * we won't race with the interrupt handler as it'll be blocked on
0279      * runtime resume.
0280      */
0281     ret = arizona_poll_reg(arizona, 30, ARIZONA_INTERRUPT_RAW_STATUS_5,
0282                    ARIZONA_BOOT_DONE_STS, ARIZONA_BOOT_DONE_STS);
0283 
0284     if (!ret)
0285         regmap_write(arizona->regmap, ARIZONA_INTERRUPT_STATUS_5,
0286                  ARIZONA_BOOT_DONE_STS);
0287 
0288     pm_runtime_mark_last_busy(arizona->dev);
0289 
0290     return ret;
0291 }
0292 
0293 static inline void arizona_enable_reset(struct arizona *arizona)
0294 {
0295     if (arizona->pdata.reset)
0296         gpiod_set_raw_value_cansleep(arizona->pdata.reset, 0);
0297 }
0298 
0299 static void arizona_disable_reset(struct arizona *arizona)
0300 {
0301     if (arizona->pdata.reset) {
0302         switch (arizona->type) {
0303         case WM5110:
0304         case WM8280:
0305             /* Meet requirements for minimum reset duration */
0306             usleep_range(5000, 10000);
0307             break;
0308         default:
0309             break;
0310         }
0311 
0312         gpiod_set_raw_value_cansleep(arizona->pdata.reset, 1);
0313         usleep_range(1000, 5000);
0314     }
0315 }
0316 
0317 struct arizona_sysclk_state {
0318     unsigned int fll;
0319     unsigned int sysclk;
0320 };
0321 
0322 static int arizona_enable_freerun_sysclk(struct arizona *arizona,
0323                      struct arizona_sysclk_state *state)
0324 {
0325     int ret, err;
0326 
0327     /* Cache existing FLL and SYSCLK settings */
0328     ret = regmap_read(arizona->regmap, ARIZONA_FLL1_CONTROL_1, &state->fll);
0329     if (ret) {
0330         dev_err(arizona->dev, "Failed to cache FLL settings: %d\n",
0331             ret);
0332         return ret;
0333     }
0334     ret = regmap_read(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1,
0335               &state->sysclk);
0336     if (ret) {
0337         dev_err(arizona->dev, "Failed to cache SYSCLK settings: %d\n",
0338             ret);
0339         return ret;
0340     }
0341 
0342     /* Start up SYSCLK using the FLL in free running mode */
0343     ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1,
0344             ARIZONA_FLL1_ENA | ARIZONA_FLL1_FREERUN);
0345     if (ret) {
0346         dev_err(arizona->dev,
0347             "Failed to start FLL in freerunning mode: %d\n",
0348             ret);
0349         return ret;
0350     }
0351     ret = arizona_poll_reg(arizona, 180, ARIZONA_INTERRUPT_RAW_STATUS_5,
0352                    ARIZONA_FLL1_CLOCK_OK_STS,
0353                    ARIZONA_FLL1_CLOCK_OK_STS);
0354     if (ret)
0355         goto err_fll;
0356 
0357     ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 0x0144);
0358     if (ret) {
0359         dev_err(arizona->dev, "Failed to start SYSCLK: %d\n", ret);
0360         goto err_fll;
0361     }
0362 
0363     return 0;
0364 
0365 err_fll:
0366     err = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll);
0367     if (err)
0368         dev_err(arizona->dev,
0369             "Failed to re-apply old FLL settings: %d\n", err);
0370 
0371     return ret;
0372 }
0373 
0374 static int arizona_disable_freerun_sysclk(struct arizona *arizona,
0375                       struct arizona_sysclk_state *state)
0376 {
0377     int ret;
0378 
0379     ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1,
0380                state->sysclk);
0381     if (ret) {
0382         dev_err(arizona->dev,
0383             "Failed to re-apply old SYSCLK settings: %d\n", ret);
0384         return ret;
0385     }
0386 
0387     ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll);
0388     if (ret) {
0389         dev_err(arizona->dev,
0390             "Failed to re-apply old FLL settings: %d\n", ret);
0391         return ret;
0392     }
0393 
0394     return 0;
0395 }
0396 
0397 static int wm5102_apply_hardware_patch(struct arizona *arizona)
0398 {
0399     struct arizona_sysclk_state state;
0400     int err, ret;
0401 
0402     ret = arizona_enable_freerun_sysclk(arizona, &state);
0403     if (ret)
0404         return ret;
0405 
0406     /* Start the write sequencer and wait for it to finish */
0407     ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0,
0408                ARIZONA_WSEQ_ENA | ARIZONA_WSEQ_START | 160);
0409     if (ret) {
0410         dev_err(arizona->dev, "Failed to start write sequencer: %d\n",
0411             ret);
0412         goto err;
0413     }
0414 
0415     ret = arizona_poll_reg(arizona, 30, ARIZONA_WRITE_SEQUENCER_CTRL_1,
0416                    ARIZONA_WSEQ_BUSY, 0);
0417     if (ret)
0418         regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0,
0419                  ARIZONA_WSEQ_ABORT);
0420 
0421 err:
0422     err = arizona_disable_freerun_sysclk(arizona, &state);
0423 
0424     return ret ?: err;
0425 }
0426 
0427 /*
0428  * Register patch to some of the CODECs internal write sequences
0429  * to ensure a clean exit from the low power sleep state.
0430  */
0431 static const struct reg_sequence wm5110_sleep_patch[] = {
0432     { 0x337A, 0xC100 },
0433     { 0x337B, 0x0041 },
0434     { 0x3300, 0xA210 },
0435     { 0x3301, 0x050C },
0436 };
0437 
0438 static int wm5110_apply_sleep_patch(struct arizona *arizona)
0439 {
0440     struct arizona_sysclk_state state;
0441     int err, ret;
0442 
0443     ret = arizona_enable_freerun_sysclk(arizona, &state);
0444     if (ret)
0445         return ret;
0446 
0447     ret = regmap_multi_reg_write_bypassed(arizona->regmap,
0448                           wm5110_sleep_patch,
0449                           ARRAY_SIZE(wm5110_sleep_patch));
0450 
0451     err = arizona_disable_freerun_sysclk(arizona, &state);
0452 
0453     return ret ?: err;
0454 }
0455 
0456 static int wm5102_clear_write_sequencer(struct arizona *arizona)
0457 {
0458     int ret;
0459 
0460     ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_3,
0461                0x0);
0462     if (ret) {
0463         dev_err(arizona->dev,
0464             "Failed to clear write sequencer state: %d\n", ret);
0465         return ret;
0466     }
0467 
0468     arizona_enable_reset(arizona);
0469     regulator_disable(arizona->dcvdd);
0470 
0471     msleep(20);
0472 
0473     ret = regulator_enable(arizona->dcvdd);
0474     if (ret) {
0475         dev_err(arizona->dev, "Failed to re-enable DCVDD: %d\n", ret);
0476         return ret;
0477     }
0478     arizona_disable_reset(arizona);
0479 
0480     return 0;
0481 }
0482 
0483 #ifdef CONFIG_PM
0484 static int arizona_isolate_dcvdd(struct arizona *arizona)
0485 {
0486     int ret;
0487 
0488     ret = regmap_update_bits(arizona->regmap,
0489                  ARIZONA_ISOLATION_CONTROL,
0490                  ARIZONA_ISOLATE_DCVDD1,
0491                  ARIZONA_ISOLATE_DCVDD1);
0492     if (ret != 0)
0493         dev_err(arizona->dev, "Failed to isolate DCVDD: %d\n", ret);
0494 
0495     return ret;
0496 }
0497 
0498 static int arizona_connect_dcvdd(struct arizona *arizona)
0499 {
0500     int ret;
0501 
0502     ret = regmap_update_bits(arizona->regmap,
0503                  ARIZONA_ISOLATION_CONTROL,
0504                  ARIZONA_ISOLATE_DCVDD1, 0);
0505     if (ret != 0)
0506         dev_err(arizona->dev, "Failed to connect DCVDD: %d\n", ret);
0507 
0508     return ret;
0509 }
0510 
0511 static int arizona_is_jack_det_active(struct arizona *arizona)
0512 {
0513     unsigned int val;
0514     int ret;
0515 
0516     ret = regmap_read(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, &val);
0517     if (ret) {
0518         dev_err(arizona->dev,
0519             "Failed to check jack det status: %d\n", ret);
0520         return ret;
0521     } else if (val & ARIZONA_JD1_ENA) {
0522         return 1;
0523     } else {
0524         return 0;
0525     }
0526 }
0527 
0528 static int arizona_runtime_resume(struct device *dev)
0529 {
0530     struct arizona *arizona = dev_get_drvdata(dev);
0531     int ret;
0532 
0533     dev_dbg(arizona->dev, "Leaving AoD mode\n");
0534 
0535     if (arizona->has_fully_powered_off) {
0536         dev_dbg(arizona->dev, "Re-enabling core supplies\n");
0537 
0538         ret = regulator_bulk_enable(arizona->num_core_supplies,
0539                         arizona->core_supplies);
0540         if (ret) {
0541             dev_err(dev, "Failed to enable core supplies: %d\n",
0542                 ret);
0543             return ret;
0544         }
0545     }
0546 
0547     ret = regulator_enable(arizona->dcvdd);
0548     if (ret != 0) {
0549         dev_err(arizona->dev, "Failed to enable DCVDD: %d\n", ret);
0550         if (arizona->has_fully_powered_off)
0551             regulator_bulk_disable(arizona->num_core_supplies,
0552                            arizona->core_supplies);
0553         return ret;
0554     }
0555 
0556     if (arizona->has_fully_powered_off) {
0557         arizona_disable_reset(arizona);
0558         enable_irq(arizona->irq);
0559         arizona->has_fully_powered_off = false;
0560     }
0561 
0562     regcache_cache_only(arizona->regmap, false);
0563 
0564     switch (arizona->type) {
0565     case WM5102:
0566         if (arizona->external_dcvdd) {
0567             ret = arizona_connect_dcvdd(arizona);
0568             if (ret != 0)
0569                 goto err;
0570         }
0571 
0572         ret = wm5102_patch(arizona);
0573         if (ret != 0) {
0574             dev_err(arizona->dev, "Failed to apply patch: %d\n",
0575                 ret);
0576             goto err;
0577         }
0578 
0579         ret = wm5102_apply_hardware_patch(arizona);
0580         if (ret) {
0581             dev_err(arizona->dev,
0582                 "Failed to apply hardware patch: %d\n",
0583                 ret);
0584             goto err;
0585         }
0586         break;
0587     case WM5110:
0588     case WM8280:
0589         ret = arizona_wait_for_boot(arizona);
0590         if (ret)
0591             goto err;
0592 
0593         if (arizona->external_dcvdd) {
0594             ret = arizona_connect_dcvdd(arizona);
0595             if (ret != 0)
0596                 goto err;
0597         } else {
0598             /*
0599              * As this is only called for the internal regulator
0600              * (where we know voltage ranges available) it is ok
0601              * to request an exact range.
0602              */
0603             ret = regulator_set_voltage(arizona->dcvdd,
0604                             1200000, 1200000);
0605             if (ret < 0) {
0606                 dev_err(arizona->dev,
0607                     "Failed to set resume voltage: %d\n",
0608                     ret);
0609                 goto err;
0610             }
0611         }
0612 
0613         ret = wm5110_apply_sleep_patch(arizona);
0614         if (ret) {
0615             dev_err(arizona->dev,
0616                 "Failed to re-apply sleep patch: %d\n",
0617                 ret);
0618             goto err;
0619         }
0620         break;
0621     case WM1831:
0622     case CS47L24:
0623         ret = arizona_wait_for_boot(arizona);
0624         if (ret != 0)
0625             goto err;
0626         break;
0627     default:
0628         ret = arizona_wait_for_boot(arizona);
0629         if (ret != 0)
0630             goto err;
0631 
0632         if (arizona->external_dcvdd) {
0633             ret = arizona_connect_dcvdd(arizona);
0634             if (ret != 0)
0635                 goto err;
0636         }
0637         break;
0638     }
0639 
0640     ret = regcache_sync(arizona->regmap);
0641     if (ret != 0) {
0642         dev_err(arizona->dev, "Failed to restore register cache\n");
0643         goto err;
0644     }
0645 
0646     return 0;
0647 
0648 err:
0649     regcache_cache_only(arizona->regmap, true);
0650     regulator_disable(arizona->dcvdd);
0651     return ret;
0652 }
0653 
0654 static int arizona_runtime_suspend(struct device *dev)
0655 {
0656     struct arizona *arizona = dev_get_drvdata(dev);
0657     int jd_active = 0;
0658     int ret;
0659 
0660     dev_dbg(arizona->dev, "Entering AoD mode\n");
0661 
0662     switch (arizona->type) {
0663     case WM5110:
0664     case WM8280:
0665         jd_active = arizona_is_jack_det_active(arizona);
0666         if (jd_active < 0)
0667             return jd_active;
0668 
0669         if (arizona->external_dcvdd) {
0670             ret = arizona_isolate_dcvdd(arizona);
0671             if (ret != 0)
0672                 return ret;
0673         } else {
0674             /*
0675              * As this is only called for the internal regulator
0676              * (where we know voltage ranges available) it is ok
0677              * to request an exact range.
0678              */
0679             ret = regulator_set_voltage(arizona->dcvdd,
0680                             1175000, 1175000);
0681             if (ret < 0) {
0682                 dev_err(arizona->dev,
0683                     "Failed to set suspend voltage: %d\n",
0684                     ret);
0685                 return ret;
0686             }
0687         }
0688         break;
0689     case WM5102:
0690         jd_active = arizona_is_jack_det_active(arizona);
0691         if (jd_active < 0)
0692             return jd_active;
0693 
0694         if (arizona->external_dcvdd) {
0695             ret = arizona_isolate_dcvdd(arizona);
0696             if (ret != 0)
0697                 return ret;
0698         }
0699 
0700         if (!jd_active) {
0701             ret = regmap_write(arizona->regmap,
0702                        ARIZONA_WRITE_SEQUENCER_CTRL_3, 0x0);
0703             if (ret) {
0704                 dev_err(arizona->dev,
0705                     "Failed to clear write sequencer: %d\n",
0706                     ret);
0707                 return ret;
0708             }
0709         }
0710         break;
0711     case WM1831:
0712     case CS47L24:
0713         break;
0714     default:
0715         jd_active = arizona_is_jack_det_active(arizona);
0716         if (jd_active < 0)
0717             return jd_active;
0718 
0719         if (arizona->external_dcvdd) {
0720             ret = arizona_isolate_dcvdd(arizona);
0721             if (ret != 0)
0722                 return ret;
0723         }
0724         break;
0725     }
0726 
0727     regcache_cache_only(arizona->regmap, true);
0728     regcache_mark_dirty(arizona->regmap);
0729     regulator_disable(arizona->dcvdd);
0730 
0731     /* Allow us to completely power down if no jack detection */
0732     if (!jd_active) {
0733         dev_dbg(arizona->dev, "Fully powering off\n");
0734 
0735         arizona->has_fully_powered_off = true;
0736 
0737         disable_irq_nosync(arizona->irq);
0738         arizona_enable_reset(arizona);
0739         regulator_bulk_disable(arizona->num_core_supplies,
0740                        arizona->core_supplies);
0741     }
0742 
0743     return 0;
0744 }
0745 #endif
0746 
0747 #ifdef CONFIG_PM_SLEEP
0748 static int arizona_suspend(struct device *dev)
0749 {
0750     struct arizona *arizona = dev_get_drvdata(dev);
0751 
0752     dev_dbg(arizona->dev, "Suspend, disabling IRQ\n");
0753     disable_irq(arizona->irq);
0754 
0755     return 0;
0756 }
0757 
0758 static int arizona_suspend_noirq(struct device *dev)
0759 {
0760     struct arizona *arizona = dev_get_drvdata(dev);
0761 
0762     dev_dbg(arizona->dev, "Late suspend, reenabling IRQ\n");
0763     enable_irq(arizona->irq);
0764 
0765     return 0;
0766 }
0767 
0768 static int arizona_resume_noirq(struct device *dev)
0769 {
0770     struct arizona *arizona = dev_get_drvdata(dev);
0771 
0772     dev_dbg(arizona->dev, "Early resume, disabling IRQ\n");
0773     disable_irq(arizona->irq);
0774 
0775     return 0;
0776 }
0777 
0778 static int arizona_resume(struct device *dev)
0779 {
0780     struct arizona *arizona = dev_get_drvdata(dev);
0781 
0782     dev_dbg(arizona->dev, "Resume, reenabling IRQ\n");
0783     enable_irq(arizona->irq);
0784 
0785     return 0;
0786 }
0787 #endif
0788 
0789 const struct dev_pm_ops arizona_pm_ops = {
0790     SET_RUNTIME_PM_OPS(arizona_runtime_suspend,
0791                arizona_runtime_resume,
0792                NULL)
0793     SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend, arizona_resume)
0794     SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(arizona_suspend_noirq,
0795                       arizona_resume_noirq)
0796 };
0797 EXPORT_SYMBOL_GPL(arizona_pm_ops);
0798 
0799 #ifdef CONFIG_OF
0800 static int arizona_of_get_core_pdata(struct arizona *arizona)
0801 {
0802     struct arizona_pdata *pdata = &arizona->pdata;
0803     int ret, i;
0804 
0805     /* Handle old non-standard DT binding */
0806     pdata->reset = devm_gpiod_get(arizona->dev, "wlf,reset", GPIOD_OUT_LOW);
0807     if (IS_ERR(pdata->reset)) {
0808         ret = PTR_ERR(pdata->reset);
0809 
0810         /*
0811          * Reset missing will be caught when other binding is read
0812          * but all other errors imply this binding is in use but has
0813          * encountered a problem so should be handled.
0814          */
0815         if (ret == -EPROBE_DEFER)
0816             return ret;
0817         else if (ret != -ENOENT && ret != -ENOSYS)
0818             dev_err(arizona->dev, "Reset GPIO malformed: %d\n",
0819                 ret);
0820 
0821         pdata->reset = NULL;
0822     }
0823 
0824     ret = of_property_read_u32_array(arizona->dev->of_node,
0825                      "wlf,gpio-defaults",
0826                      pdata->gpio_defaults,
0827                      ARRAY_SIZE(pdata->gpio_defaults));
0828     if (ret >= 0) {
0829         /*
0830          * All values are literal except out of range values
0831          * which are chip default, translate into platform
0832          * data which uses 0 as chip default and out of range
0833          * as zero.
0834          */
0835         for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
0836             if (pdata->gpio_defaults[i] > 0xffff)
0837                 pdata->gpio_defaults[i] = 0;
0838             else if (pdata->gpio_defaults[i] == 0)
0839                 pdata->gpio_defaults[i] = 0x10000;
0840         }
0841     } else {
0842         dev_err(arizona->dev, "Failed to parse GPIO defaults: %d\n",
0843             ret);
0844     }
0845 
0846     return 0;
0847 }
0848 #else
0849 static inline int arizona_of_get_core_pdata(struct arizona *arizona)
0850 {
0851     return 0;
0852 }
0853 #endif
0854 
0855 static const struct mfd_cell early_devs[] = {
0856     { .name = "arizona-ldo1" },
0857 };
0858 
0859 static const char * const wm5102_supplies[] = {
0860     "MICVDD",
0861     "DBVDD2",
0862     "DBVDD3",
0863     "CPVDD",
0864     "SPKVDDL",
0865     "SPKVDDR",
0866 };
0867 
0868 static const struct mfd_cell wm5102_devs[] = {
0869     { .name = "arizona-micsupp" },
0870     { .name = "arizona-gpio" },
0871     { .name = "arizona-haptics" },
0872     { .name = "arizona-pwm" },
0873     {
0874         .name = "wm5102-codec",
0875         .parent_supplies = wm5102_supplies,
0876         .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
0877     },
0878 };
0879 
0880 static const struct mfd_cell wm5110_devs[] = {
0881     { .name = "arizona-micsupp" },
0882     { .name = "arizona-gpio" },
0883     { .name = "arizona-haptics" },
0884     { .name = "arizona-pwm" },
0885     {
0886         .name = "wm5110-codec",
0887         .parent_supplies = wm5102_supplies,
0888         .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
0889     },
0890 };
0891 
0892 static const char * const cs47l24_supplies[] = {
0893     "MICVDD",
0894     "CPVDD",
0895     "SPKVDD",
0896 };
0897 
0898 static const struct mfd_cell cs47l24_devs[] = {
0899     { .name = "arizona-gpio" },
0900     { .name = "arizona-haptics" },
0901     { .name = "arizona-pwm" },
0902     {
0903         .name = "cs47l24-codec",
0904         .parent_supplies = cs47l24_supplies,
0905         .num_parent_supplies = ARRAY_SIZE(cs47l24_supplies),
0906     },
0907 };
0908 
0909 static const char * const wm8997_supplies[] = {
0910     "MICVDD",
0911     "DBVDD2",
0912     "CPVDD",
0913     "SPKVDD",
0914 };
0915 
0916 static const struct mfd_cell wm8997_devs[] = {
0917     { .name = "arizona-micsupp" },
0918     { .name = "arizona-gpio" },
0919     { .name = "arizona-haptics" },
0920     { .name = "arizona-pwm" },
0921     {
0922         .name = "wm8997-codec",
0923         .parent_supplies = wm8997_supplies,
0924         .num_parent_supplies = ARRAY_SIZE(wm8997_supplies),
0925     },
0926 };
0927 
0928 static const struct mfd_cell wm8998_devs[] = {
0929     { .name = "arizona-micsupp" },
0930     { .name = "arizona-gpio" },
0931     { .name = "arizona-haptics" },
0932     { .name = "arizona-pwm" },
0933     {
0934         .name = "wm8998-codec",
0935         .parent_supplies = wm5102_supplies,
0936         .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
0937     },
0938 };
0939 
0940 int arizona_dev_init(struct arizona *arizona)
0941 {
0942     static const char * const mclk_name[] = { "mclk1", "mclk2" };
0943     struct device *dev = arizona->dev;
0944     const char *type_name = NULL;
0945     unsigned int reg, val;
0946     int (*apply_patch)(struct arizona *) = NULL;
0947     const struct mfd_cell *subdevs = NULL;
0948     int n_subdevs = 0, ret, i;
0949 
0950     dev_set_drvdata(arizona->dev, arizona);
0951     mutex_init(&arizona->clk_lock);
0952 
0953     if (dev_get_platdata(arizona->dev)) {
0954         memcpy(&arizona->pdata, dev_get_platdata(arizona->dev),
0955                sizeof(arizona->pdata));
0956     } else {
0957         ret = arizona_of_get_core_pdata(arizona);
0958         if (ret < 0)
0959             return ret;
0960     }
0961 
0962     BUILD_BUG_ON(ARRAY_SIZE(arizona->mclk) != ARRAY_SIZE(mclk_name));
0963     for (i = 0; i < ARRAY_SIZE(arizona->mclk); i++) {
0964         arizona->mclk[i] = devm_clk_get(arizona->dev, mclk_name[i]);
0965         if (IS_ERR(arizona->mclk[i])) {
0966             dev_info(arizona->dev, "Failed to get %s: %ld\n",
0967                  mclk_name[i], PTR_ERR(arizona->mclk[i]));
0968             arizona->mclk[i] = NULL;
0969         }
0970     }
0971 
0972     regcache_cache_only(arizona->regmap, true);
0973 
0974     switch (arizona->type) {
0975     case WM5102:
0976     case WM5110:
0977     case WM8280:
0978     case WM8997:
0979     case WM8998:
0980     case WM1814:
0981     case WM1831:
0982     case CS47L24:
0983         for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++)
0984             arizona->core_supplies[i].supply
0985                 = wm5102_core_supplies[i];
0986         arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies);
0987         break;
0988     default:
0989         dev_err(arizona->dev, "Unknown device type %d\n",
0990             arizona->type);
0991         return -ENODEV;
0992     }
0993 
0994     /* Mark DCVDD as external, LDO1 driver will clear if internal */
0995     arizona->external_dcvdd = true;
0996 
0997     switch (arizona->type) {
0998     case WM1831:
0999     case CS47L24:
1000         break; /* No LDO1 regulator */
1001     default:
1002         ret = mfd_add_devices(arizona->dev, -1, early_devs,
1003                       ARRAY_SIZE(early_devs), NULL, 0, NULL);
1004         if (ret != 0) {
1005             dev_err(dev, "Failed to add early children: %d\n", ret);
1006             return ret;
1007         }
1008         break;
1009     }
1010 
1011     ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies,
1012                       arizona->core_supplies);
1013     if (ret != 0) {
1014         dev_err(dev, "Failed to request core supplies: %d\n",
1015             ret);
1016         goto err_early;
1017     }
1018 
1019     /**
1020      * Don't use devres here because the only device we have to get
1021      * against is the MFD device and DCVDD will likely be supplied by
1022      * one of its children. Meaning that the regulator will be
1023      * destroyed by the time devres calls regulator put.
1024      */
1025     arizona->dcvdd = regulator_get(arizona->dev, "DCVDD");
1026     if (IS_ERR(arizona->dcvdd)) {
1027         ret = PTR_ERR(arizona->dcvdd);
1028         dev_err(dev, "Failed to request DCVDD: %d\n", ret);
1029         goto err_early;
1030     }
1031 
1032     if (!arizona->pdata.reset) {
1033         /* Start out with /RESET low to put the chip into reset */
1034         arizona->pdata.reset = devm_gpiod_get(arizona->dev, "reset",
1035                               GPIOD_OUT_LOW);
1036         if (IS_ERR(arizona->pdata.reset)) {
1037             ret = PTR_ERR(arizona->pdata.reset);
1038             if (ret == -EPROBE_DEFER)
1039                 goto err_dcvdd;
1040 
1041             dev_err(arizona->dev,
1042                 "Reset GPIO missing/malformed: %d\n", ret);
1043 
1044             arizona->pdata.reset = NULL;
1045         }
1046     }
1047 
1048     ret = regulator_bulk_enable(arizona->num_core_supplies,
1049                     arizona->core_supplies);
1050     if (ret != 0) {
1051         dev_err(dev, "Failed to enable core supplies: %d\n",
1052             ret);
1053         goto err_dcvdd;
1054     }
1055 
1056     ret = regulator_enable(arizona->dcvdd);
1057     if (ret != 0) {
1058         dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
1059         goto err_enable;
1060     }
1061 
1062     arizona_disable_reset(arizona);
1063 
1064     regcache_cache_only(arizona->regmap, false);
1065 
1066     /* Verify that this is a chip we know about */
1067     ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1068     if (ret != 0) {
1069         dev_err(dev, "Failed to read ID register: %d\n", ret);
1070         goto err_reset;
1071     }
1072 
1073     switch (reg) {
1074     case 0x5102:
1075     case 0x5110:
1076     case 0x6349:
1077     case 0x6363:
1078     case 0x8997:
1079         break;
1080     default:
1081         dev_err(arizona->dev, "Unknown device ID: %x\n", reg);
1082         ret = -ENODEV;
1083         goto err_reset;
1084     }
1085 
1086     /* If we have a /RESET GPIO we'll already be reset */
1087     if (!arizona->pdata.reset) {
1088         ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0);
1089         if (ret != 0) {
1090             dev_err(dev, "Failed to reset device: %d\n", ret);
1091             goto err_reset;
1092         }
1093 
1094         usleep_range(1000, 5000);
1095     }
1096 
1097     /* Ensure device startup is complete */
1098     switch (arizona->type) {
1099     case WM5102:
1100         ret = regmap_read(arizona->regmap,
1101                   ARIZONA_WRITE_SEQUENCER_CTRL_3, &val);
1102         if (ret) {
1103             dev_err(dev,
1104                 "Failed to check write sequencer state: %d\n",
1105                 ret);
1106         } else if (val & 0x01) {
1107             ret = wm5102_clear_write_sequencer(arizona);
1108             if (ret)
1109                 return ret;
1110         }
1111         break;
1112     default:
1113         break;
1114     }
1115 
1116     ret = arizona_wait_for_boot(arizona);
1117     if (ret) {
1118         dev_err(arizona->dev, "Device failed initial boot: %d\n", ret);
1119         goto err_reset;
1120     }
1121 
1122     /* Read the device ID information & do device specific stuff */
1123     ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1124     if (ret != 0) {
1125         dev_err(dev, "Failed to read ID register: %d\n", ret);
1126         goto err_reset;
1127     }
1128 
1129     ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION,
1130               &arizona->rev);
1131     if (ret != 0) {
1132         dev_err(dev, "Failed to read revision register: %d\n", ret);
1133         goto err_reset;
1134     }
1135     arizona->rev &= ARIZONA_DEVICE_REVISION_MASK;
1136 
1137     switch (reg) {
1138     case 0x5102:
1139         if (IS_ENABLED(CONFIG_MFD_WM5102)) {
1140             type_name = "WM5102";
1141             if (arizona->type != WM5102) {
1142                 dev_warn(arizona->dev,
1143                      "WM5102 registered as %d\n",
1144                      arizona->type);
1145                 arizona->type = WM5102;
1146             }
1147 
1148             apply_patch = wm5102_patch;
1149             arizona->rev &= 0x7;
1150             subdevs = wm5102_devs;
1151             n_subdevs = ARRAY_SIZE(wm5102_devs);
1152         }
1153         break;
1154     case 0x5110:
1155         if (IS_ENABLED(CONFIG_MFD_WM5110)) {
1156             switch (arizona->type) {
1157             case WM5110:
1158                 type_name = "WM5110";
1159                 break;
1160             case WM8280:
1161                 type_name = "WM8280";
1162                 break;
1163             default:
1164                 type_name = "WM5110";
1165                 dev_warn(arizona->dev,
1166                      "WM5110 registered as %d\n",
1167                      arizona->type);
1168                 arizona->type = WM5110;
1169                 break;
1170             }
1171 
1172             apply_patch = wm5110_patch;
1173             subdevs = wm5110_devs;
1174             n_subdevs = ARRAY_SIZE(wm5110_devs);
1175         }
1176         break;
1177     case 0x6363:
1178         if (IS_ENABLED(CONFIG_MFD_CS47L24)) {
1179             switch (arizona->type) {
1180             case CS47L24:
1181                 type_name = "CS47L24";
1182                 break;
1183 
1184             case WM1831:
1185                 type_name = "WM1831";
1186                 break;
1187 
1188             default:
1189                 dev_warn(arizona->dev,
1190                      "CS47L24 registered as %d\n",
1191                      arizona->type);
1192                 arizona->type = CS47L24;
1193                 break;
1194             }
1195 
1196             apply_patch = cs47l24_patch;
1197             subdevs = cs47l24_devs;
1198             n_subdevs = ARRAY_SIZE(cs47l24_devs);
1199         }
1200         break;
1201     case 0x8997:
1202         if (IS_ENABLED(CONFIG_MFD_WM8997)) {
1203             type_name = "WM8997";
1204             if (arizona->type != WM8997) {
1205                 dev_warn(arizona->dev,
1206                      "WM8997 registered as %d\n",
1207                      arizona->type);
1208                 arizona->type = WM8997;
1209             }
1210 
1211             apply_patch = wm8997_patch;
1212             subdevs = wm8997_devs;
1213             n_subdevs = ARRAY_SIZE(wm8997_devs);
1214         }
1215         break;
1216     case 0x6349:
1217         if (IS_ENABLED(CONFIG_MFD_WM8998)) {
1218             switch (arizona->type) {
1219             case WM8998:
1220                 type_name = "WM8998";
1221                 break;
1222 
1223             case WM1814:
1224                 type_name = "WM1814";
1225                 break;
1226 
1227             default:
1228                 type_name = "WM8998";
1229                 dev_warn(arizona->dev,
1230                      "WM8998 registered as %d\n",
1231                      arizona->type);
1232                 arizona->type = WM8998;
1233             }
1234 
1235             apply_patch = wm8998_patch;
1236             subdevs = wm8998_devs;
1237             n_subdevs = ARRAY_SIZE(wm8998_devs);
1238         }
1239         break;
1240     default:
1241         dev_err(arizona->dev, "Unknown device ID %x\n", reg);
1242         ret = -ENODEV;
1243         goto err_reset;
1244     }
1245 
1246     if (!subdevs) {
1247         dev_err(arizona->dev,
1248             "No kernel support for device ID %x\n", reg);
1249         ret = -ENODEV;
1250         goto err_reset;
1251     }
1252 
1253     dev_info(dev, "%s revision %c\n", type_name, arizona->rev + 'A');
1254 
1255     if (apply_patch) {
1256         ret = apply_patch(arizona);
1257         if (ret != 0) {
1258             dev_err(arizona->dev, "Failed to apply patch: %d\n",
1259                 ret);
1260             goto err_reset;
1261         }
1262 
1263         switch (arizona->type) {
1264         case WM5102:
1265             ret = wm5102_apply_hardware_patch(arizona);
1266             if (ret) {
1267                 dev_err(arizona->dev,
1268                     "Failed to apply hardware patch: %d\n",
1269                     ret);
1270                 goto err_reset;
1271             }
1272             break;
1273         case WM5110:
1274         case WM8280:
1275             ret = wm5110_apply_sleep_patch(arizona);
1276             if (ret) {
1277                 dev_err(arizona->dev,
1278                     "Failed to apply sleep patch: %d\n",
1279                     ret);
1280                 goto err_reset;
1281             }
1282             break;
1283         default:
1284             break;
1285         }
1286     }
1287 
1288     for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) {
1289         if (!arizona->pdata.gpio_defaults[i])
1290             continue;
1291 
1292         regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i,
1293                  arizona->pdata.gpio_defaults[i]);
1294     }
1295 
1296     /* Chip default */
1297     if (!arizona->pdata.clk32k_src)
1298         arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2;
1299 
1300     switch (arizona->pdata.clk32k_src) {
1301     case ARIZONA_32KZ_MCLK1:
1302     case ARIZONA_32KZ_MCLK2:
1303         regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1304                    ARIZONA_CLK_32K_SRC_MASK,
1305                    arizona->pdata.clk32k_src - 1);
1306         arizona_clk32k_enable(arizona);
1307         break;
1308     case ARIZONA_32KZ_NONE:
1309         regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1310                    ARIZONA_CLK_32K_SRC_MASK, 2);
1311         break;
1312     default:
1313         dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n",
1314             arizona->pdata.clk32k_src);
1315         ret = -EINVAL;
1316         goto err_reset;
1317     }
1318 
1319     for (i = 0; i < ARIZONA_MAX_MICBIAS; i++) {
1320         if (!arizona->pdata.micbias[i].mV &&
1321             !arizona->pdata.micbias[i].bypass)
1322             continue;
1323 
1324         /* Apply default for bypass mode */
1325         if (!arizona->pdata.micbias[i].mV)
1326             arizona->pdata.micbias[i].mV = 2800;
1327 
1328         val = (arizona->pdata.micbias[i].mV - 1500) / 100;
1329 
1330         val <<= ARIZONA_MICB1_LVL_SHIFT;
1331 
1332         if (arizona->pdata.micbias[i].ext_cap)
1333             val |= ARIZONA_MICB1_EXT_CAP;
1334 
1335         if (arizona->pdata.micbias[i].discharge)
1336             val |= ARIZONA_MICB1_DISCH;
1337 
1338         if (arizona->pdata.micbias[i].soft_start)
1339             val |= ARIZONA_MICB1_RATE;
1340 
1341         if (arizona->pdata.micbias[i].bypass)
1342             val |= ARIZONA_MICB1_BYPASS;
1343 
1344         regmap_update_bits(arizona->regmap,
1345                    ARIZONA_MIC_BIAS_CTRL_1 + i,
1346                    ARIZONA_MICB1_LVL_MASK |
1347                    ARIZONA_MICB1_EXT_CAP |
1348                    ARIZONA_MICB1_DISCH |
1349                    ARIZONA_MICB1_BYPASS |
1350                    ARIZONA_MICB1_RATE, val);
1351     }
1352 
1353     pm_runtime_set_active(arizona->dev);
1354     pm_runtime_enable(arizona->dev);
1355 
1356     /* Set up for interrupts */
1357     ret = arizona_irq_init(arizona);
1358     if (ret != 0)
1359         goto err_pm;
1360 
1361     pm_runtime_set_autosuspend_delay(arizona->dev, 100);
1362     pm_runtime_use_autosuspend(arizona->dev);
1363 
1364     arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error",
1365                 arizona_clkgen_err, arizona);
1366     arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked",
1367                 arizona_overclocked, arizona);
1368     arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked",
1369                 arizona_underclocked, arizona);
1370 
1371     ret = mfd_add_devices(arizona->dev, PLATFORM_DEVID_NONE,
1372                   subdevs, n_subdevs, NULL, 0, NULL);
1373 
1374     if (ret) {
1375         dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret);
1376         goto err_irq;
1377     }
1378 
1379     return 0;
1380 
1381 err_irq:
1382     arizona_irq_exit(arizona);
1383 err_pm:
1384     pm_runtime_disable(arizona->dev);
1385 
1386     switch (arizona->pdata.clk32k_src) {
1387     case ARIZONA_32KZ_MCLK1:
1388     case ARIZONA_32KZ_MCLK2:
1389         arizona_clk32k_disable(arizona);
1390         break;
1391     default:
1392         break;
1393     }
1394 err_reset:
1395     arizona_enable_reset(arizona);
1396     regulator_disable(arizona->dcvdd);
1397 err_enable:
1398     regulator_bulk_disable(arizona->num_core_supplies,
1399                    arizona->core_supplies);
1400 err_dcvdd:
1401     regulator_put(arizona->dcvdd);
1402 err_early:
1403     mfd_remove_devices(dev);
1404     return ret;
1405 }
1406 EXPORT_SYMBOL_GPL(arizona_dev_init);
1407 
1408 int arizona_dev_exit(struct arizona *arizona)
1409 {
1410     disable_irq(arizona->irq);
1411     pm_runtime_disable(arizona->dev);
1412 
1413     regulator_disable(arizona->dcvdd);
1414     regulator_put(arizona->dcvdd);
1415 
1416     switch (arizona->pdata.clk32k_src) {
1417     case ARIZONA_32KZ_MCLK1:
1418     case ARIZONA_32KZ_MCLK2:
1419         arizona_clk32k_disable(arizona);
1420         break;
1421     default:
1422         break;
1423     }
1424 
1425     mfd_remove_devices(arizona->dev);
1426     arizona_free_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, arizona);
1427     arizona_free_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, arizona);
1428     arizona_free_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, arizona);
1429     arizona_irq_exit(arizona);
1430     arizona_enable_reset(arizona);
1431 
1432     regulator_bulk_disable(arizona->num_core_supplies,
1433                    arizona->core_supplies);
1434     return 0;
1435 }
1436 EXPORT_SYMBOL_GPL(arizona_dev_exit);
1437 
1438 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!