1 files changed, 126 insertions, 87 deletions

diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c
index 5e05eed96c3..c6106753090 100644
--- a/sound/soc/codecs/wm8962.c
+++ b/sound/soc/codecs/wm8962.c
@@ -78,6 +78,8 @@ struct wm8962_priv {
 #ifdef CONFIG_GPIOLIB
         struct gpio_chip gpio_chip;
 #endif
+
+        int irq;
 };
 
 /* We can't use the same notifier block for more than one supply and
@@ -1957,7 +1959,13 @@ static int wm8962_readable_register(struct snd_soc_codec *codec, unsigned int re
 
 static int wm8962_reset(struct snd_soc_codec *codec)
 {
-        return snd_soc_write(codec, WM8962_SOFTWARE_RESET, 0x6243);
+        int ret;
+
+        ret = snd_soc_write(codec, WM8962_SOFTWARE_RESET, 0x6243);
+        if (ret != 0)
+                return ret;
+
+        return snd_soc_write(codec, WM8962_PLL_SOFTWARE_RESET, 0);
 }
 
 static const DECLARE_TLV_DB_SCALE(inpga_tlv, -2325, 75, 0);
@@ -1982,6 +1990,7 @@ static const unsigned int classd_tlv[] = {
         0, 6, TLV_DB_SCALE_ITEM(0, 150, 0),
         7, 7, TLV_DB_SCALE_ITEM(1200, 0, 0),
 };
+static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
 
 /* The VU bits for the headphones are in a different register to the mute
  * bits and only take effect on the PGA if it is actually powered.
@@ -2018,7 +2027,6 @@ static int wm8962_put_spk_sw(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
-        u16 *reg_cache = codec->reg_cache;
         int ret;
 
         /* Apply the update (if any) */
@@ -2027,16 +2035,19 @@ static int wm8962_put_spk_sw(struct snd_kcontrol *kcontrol,
                 return 0;
 
         /* If the left PGA is enabled hit that VU bit... */
-        if (reg_cache[WM8962_PWR_MGMT_2] & WM8962_SPKOUTL_PGA_ENA)
-                return snd_soc_write(codec, WM8962_SPKOUTL_VOLUME,
-                                     reg_cache[WM8962_SPKOUTL_VOLUME]);
+        ret = snd_soc_read(codec, WM8962_PWR_MGMT_2);
+        if (ret & WM8962_SPKOUTL_PGA_ENA) {
+                snd_soc_write(codec, WM8962_SPKOUTL_VOLUME,
+                              snd_soc_read(codec, WM8962_SPKOUTL_VOLUME));
+                return 1;
+        }
 
         /* ...otherwise the right.  The VU is stereo. */
-        if (reg_cache[WM8962_PWR_MGMT_2] & WM8962_SPKOUTR_PGA_ENA)
-                return snd_soc_write(codec, WM8962_SPKOUTR_VOLUME,
-                                     reg_cache[WM8962_SPKOUTR_VOLUME]);
+        if (ret & WM8962_SPKOUTR_PGA_ENA)
+                snd_soc_write(codec, WM8962_SPKOUTR_VOLUME,
+                              snd_soc_read(codec, WM8962_SPKOUTR_VOLUME));
 
-        return 0;
+        return 1;
 }
 
 static const char *cap_hpf_mode_text[] = {
@@ -2119,6 +2130,18 @@ SOC_SINGLE_TLV("HPMIXR MIXINR Volume", WM8962_HEADPHONE_MIXER_4,
 
 SOC_SINGLE_TLV("Speaker Boost Volume", WM8962_CLASS_D_CONTROL_2, 0, 7, 0,
                classd_tlv),
+
+SOC_SINGLE("EQ Switch", WM8962_EQ1, WM8962_EQ_ENA_SHIFT, 1, 0),
+SOC_DOUBLE_R_TLV("EQ1 Volume", WM8962_EQ2, WM8962_EQ22,
+                 WM8962_EQL_B1_GAIN_SHIFT, 31, 0, eq_tlv),
+SOC_DOUBLE_R_TLV("EQ2 Volume", WM8962_EQ2, WM8962_EQ22,
+                 WM8962_EQL_B2_GAIN_SHIFT, 31, 0, eq_tlv),
+SOC_DOUBLE_R_TLV("EQ3 Volume", WM8962_EQ2, WM8962_EQ22,
+                 WM8962_EQL_B3_GAIN_SHIFT, 31, 0, eq_tlv),
+SOC_DOUBLE_R_TLV("EQ4 Volume", WM8962_EQ3, WM8962_EQ23,
+                 WM8962_EQL_B4_GAIN_SHIFT, 31, 0, eq_tlv),
+SOC_DOUBLE_R_TLV("EQ5 Volume", WM8962_EQ3, WM8962_EQ23,
+                 WM8962_EQL_B5_GAIN_SHIFT, 31, 0, eq_tlv),
 };
 
 static const struct snd_kcontrol_new wm8962_spk_mono_controls[] = {
@@ -2184,6 +2207,8 @@ static int sysclk_event(struct snd_soc_dapm_widget *w,
                         struct snd_kcontrol *kcontrol, int event)
 {
         struct snd_soc_codec *codec = w->codec;
+        struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
+        unsigned long timeout;
         int src;
         int fll;
 
@@ -2203,9 +2228,20 @@ static int sysclk_event(struct snd_soc_dapm_widget *w,
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
-                if (fll)
+                if (fll) {
+                        try_wait_for_completion(&wm8962->fll_lock);
+
                         snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1,
                                             WM8962_FLL_ENA, WM8962_FLL_ENA);
+
+                        timeout = msecs_to_jiffies(5);
+                        timeout = wait_for_completion_timeout(&wm8962->fll_lock,
+                                                              timeout);
+
+                        if (wm8962->irq && timeout == 0)
+                                dev_err(codec->dev,
+                                        "Timed out starting FLL\n");
+                }
                 break;
 
         case SND_SOC_DAPM_POST_PMD:
@@ -2336,7 +2372,6 @@ static int out_pga_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
         struct snd_soc_codec *codec = w->codec;
-        u16 *reg_cache = codec->reg_cache;
         int reg;
 
         switch (w->shift) {
@@ -2359,7 +2394,7 @@ static int out_pga_event(struct snd_soc_dapm_widget *w,
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
-                return snd_soc_write(codec, reg, reg_cache[reg]);
+                return snd_soc_write(codec, reg, snd_soc_read(codec, reg));
         default:
                 BUG();
                 return -EINVAL;
@@ -2763,18 +2798,44 @@ static const int bclk_divs[] = {
         1, -1, 2, 3, 4, -1, 6, 8, -1, 12, 16, 24, -1, 32, 32, 32
 };
 
+static const int sysclk_rates[] = {
+        64, 128, 192, 256, 384, 512, 768, 1024, 1408, 1536,
+};
+
 static void wm8962_configure_bclk(struct snd_soc_codec *codec)
 {
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
         int dspclk, i;
         int clocking2 = 0;
+        int clocking4 = 0;
         int aif2 = 0;
 
-        if (!wm8962->bclk) {
-                dev_dbg(codec->dev, "No BCLK rate configured\n");
+        if (!wm8962->sysclk_rate) {
+                dev_dbg(codec->dev, "No SYSCLK configured\n");
                 return;
         }
 
+        if (!wm8962->bclk || !wm8962->lrclk) {
+                dev_dbg(codec->dev, "No audio clocks configured\n");
+                return;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(sysclk_rates); i++) {
+                if (sysclk_rates[i] == wm8962->sysclk_rate / wm8962->lrclk) {
+                        clocking4 |= i << WM8962_SYSCLK_RATE_SHIFT;
+                        break;
+                }
+        }
+
+        if (i == ARRAY_SIZE(sysclk_rates)) {
+                dev_err(codec->dev, "Unsupported sysclk ratio %d\n",
+                        wm8962->sysclk_rate / wm8962->lrclk);
+                return;
+        }
+
+        snd_soc_update_bits(codec, WM8962_CLOCKING_4,
+                            WM8962_SYSCLK_RATE_MASK, clocking4);
+
         dspclk = snd_soc_read(codec, WM8962_CLOCKING1);
         if (dspclk < 0) {
                 dev_err(codec->dev, "Failed to read DSPCLK: %d\n", dspclk);
@@ -2844,6 +2905,8 @@ static int wm8962_set_bias_level(struct snd_soc_codec *codec,
                 /* VMID 2*50k */
                 snd_soc_update_bits(codec, WM8962_PWR_MGMT_1,
                                     WM8962_VMID_SEL_MASK, 0x80);
+
+                wm8962_configure_bclk(codec);
                 break;
 
         case SND_SOC_BIAS_STANDBY:
@@ -2872,12 +2935,6 @@ static int wm8962_set_bias_level(struct snd_soc_codec *codec,
                                             WM8962_BIAS_ENA | 0x180);
 
                         msleep(5);
-
-                        snd_soc_update_bits(codec, WM8962_CLOCKING2,
-                                            WM8962_CLKREG_OVD,
-                                            WM8962_CLKREG_OVD);
-
-                        wm8962_configure_bclk(codec);
                 }
 
                 /* VMID 2*250k */
@@ -2918,10 +2975,6 @@ static const struct {
         { 96000, 6 },
 };
 
-static const int sysclk_rates[] = {
-        64, 128, 192, 256, 384, 512, 768, 1024, 1408, 1536,
-};
-
 static int wm8962_hw_params(struct snd_pcm_substream *substream,
                             struct snd_pcm_hw_params *params,
                             struct snd_soc_dai *dai)
@@ -2929,41 +2982,27 @@ static int wm8962_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_codec *codec = rtd->codec;
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
-        int rate = params_rate(params);
         int i;
         int aif0 = 0;
         int adctl3 = 0;
-        int clocking4 = 0;
 
         wm8962->bclk = snd_soc_params_to_bclk(params);
         wm8962->lrclk = params_rate(params);
 
         for (i = 0; i < ARRAY_SIZE(sr_vals); i++) {
-                if (sr_vals[i].rate == rate) {
+                if (sr_vals[i].rate == wm8962->lrclk) {
                         adctl3 |= sr_vals[i].reg;
                         break;
                 }
         }
         if (i == ARRAY_SIZE(sr_vals)) {
-                dev_err(codec->dev, "Unsupported rate %dHz\n", rate);
+                dev_err(codec->dev, "Unsupported rate %dHz\n", wm8962->lrclk);
                 return -EINVAL;
         }
 
-        if (rate % 8000 == 0)
+        if (wm8962->lrclk % 8000 == 0)
                 adctl3 |= WM8962_SAMPLE_RATE_INT_MODE;
 
-        for (i = 0; i < ARRAY_SIZE(sysclk_rates); i++) {
-                if (sysclk_rates[i] == wm8962->sysclk_rate / rate) {
-                        clocking4 |= i << WM8962_SYSCLK_RATE_SHIFT;
-                        break;
-                }
-        }
-        if (i == ARRAY_SIZE(sysclk_rates)) {
-                dev_err(codec->dev, "Unsupported sysclk ratio %d\n",
-                        wm8962->sysclk_rate / rate);
-                return -EINVAL;
-        }
-
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
                 break;
@@ -2985,8 +3024,6 @@ static int wm8962_hw_params(struct snd_pcm_substream *substream,
         snd_soc_update_bits(codec, WM8962_ADDITIONAL_CONTROL_3,
                             WM8962_SAMPLE_RATE_INT_MODE |
                             WM8962_SAMPLE_RATE_MASK, adctl3);
-        snd_soc_update_bits(codec, WM8962_CLOCKING_4,
-                            WM8962_SYSCLK_RATE_MASK, clocking4);
 
         wm8962_configure_bclk(codec);
 
@@ -3027,9 +3064,9 @@ static int wm8962_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
         int aif0 = 0;
 
         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
-        case SND_SOC_DAIFMT_DSP_A:
-                aif0 |= WM8962_LRCLK_INV;
         case SND_SOC_DAIFMT_DSP_B:
+                aif0 |= WM8962_LRCLK_INV | 3;
+        case SND_SOC_DAIFMT_DSP_A:
                 aif0 |= 3;
 
                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
@@ -3255,22 +3292,39 @@ static int wm8962_set_fll(struct snd_soc_codec *codec, int fll_id, int source,
         snd_soc_write(codec, WM8962_FLL_CONTROL_7, fll_div.lambda);
         snd_soc_write(codec, WM8962_FLL_CONTROL_8, fll_div.n);
 
+        try_wait_for_completion(&wm8962->fll_lock);
+
         snd_soc_update_bits(codec, WM8962_FLL_CONTROL_1,
                             WM8962_FLL_FRAC | WM8962_FLL_REFCLK_SRC_MASK |
                             WM8962_FLL_ENA, fll1);
 
         dev_dbg(codec->dev, "FLL configured for %dHz->%dHz\n", Fref, Fout);
 
-        /* This should be a massive overestimate */
-        timeout = msecs_to_jiffies(1);
+        ret = 0;
+
+        if (fll1 & WM8962_FLL_ENA) {
+                /* This should be a massive overestimate but go even
+                 * higher if we'll error out
+                 */
+                if (wm8962->irq)
+                        timeout = msecs_to_jiffies(5);
+                else
+                        timeout = msecs_to_jiffies(1);
+
+                timeout = wait_for_completion_timeout(&wm8962->fll_lock,
+                                                      timeout);
 
-        wait_for_completion_timeout(&wm8962->fll_lock, timeout);
+                if (timeout == 0 && wm8962->irq) {
+                        dev_err(codec->dev, "FLL lock timed out");
+                        ret = -ETIMEDOUT;
+                }
+        }
 
         wm8962->fll_fref = Fref;
         wm8962->fll_fout = Fout;
         wm8962->fll_src = source;
 
-        return 0;
+        return ret;
 }
 
 static int wm8962_mute(struct snd_soc_dai *dai, int mute)
@@ -3361,6 +3415,9 @@ static irqreturn_t wm8962_irq(int irq, void *data)
         active = snd_soc_read(codec, WM8962_INTERRUPT_STATUS_2);
         active &= ~mask;
 
+        /* Acknowledge the interrupts */
+        snd_soc_write(codec, WM8962_INTERRUPT_STATUS_2, active);
+
         if (active & WM8962_FLL_LOCK_EINT) {
                 dev_dbg(codec->dev, "FLL locked\n");
                 complete(&wm8962->fll_lock);
@@ -3385,9 +3442,6 @@ static irqreturn_t wm8962_irq(int irq, void *data)
                                       msecs_to_jiffies(250));
         }
 
-        /* Acknowledge the interrupts */
-        snd_soc_write(codec, WM8962_INTERRUPT_STATUS_2, active);
-
         return IRQ_HANDLED;
 }
 
@@ -3431,31 +3485,6 @@ int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack)
 }
 EXPORT_SYMBOL_GPL(wm8962_mic_detect);
 
-#ifdef CONFIG_PM
-static int wm8962_resume(struct snd_soc_codec *codec)
-{
-        u16 *reg_cache = codec->reg_cache;
-        int i;
-
-        /* Restore the registers */
-        for (i = 1; i < codec->driver->reg_cache_size; i++) {
-                switch (i) {
-                case WM8962_SOFTWARE_RESET:
-                        continue;
-                default:
-                        break;
-                }
-
-                if (reg_cache[i] != wm8962_reg[i])
-                        snd_soc_write(codec, i, reg_cache[i]);
-        }
-
-        return 0;
-}
-#else
-#define wm8962_resume NULL
-#endif
-
 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int beep_rates[] = {
         500, 1000, 2000, 4000,
@@ -3731,8 +3760,6 @@ static int wm8962_probe(struct snd_soc_codec *codec)
         int ret;
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
         struct wm8962_pdata *pdata = dev_get_platdata(codec->dev);
-        struct i2c_client *i2c = container_of(codec->dev, struct i2c_client,
-                                              dev);
         u16 *reg_cache = codec->reg_cache;
         int i, trigger, irq_pol;
         bool dmicclk, dmicdat;
@@ -3822,6 +3849,15 @@ static int wm8962_probe(struct snd_soc_codec *codec)
          */
         snd_soc_update_bits(codec, WM8962_CLOCKING2, WM8962_SYSCLK_ENA, 0);
 
+        /* Ensure we have soft control over all registers */
+        snd_soc_update_bits(codec, WM8962_CLOCKING2,
+                            WM8962_CLKREG_OVD, WM8962_CLKREG_OVD);
+
+        /* Ensure that the oscillator and PLLs are disabled */
+        snd_soc_update_bits(codec, WM8962_PLL2,
+                            WM8962_OSC_ENA | WM8962_PLL2_ENA | WM8962_PLL3_ENA,
+                            0);
+
         regulator_bulk_disable(ARRAY_SIZE(wm8962->supplies), wm8962->supplies);
 
         if (pdata) {
@@ -3871,6 +3907,9 @@ static int wm8962_probe(struct snd_soc_codec *codec)
         snd_soc_update_bits(codec, WM8962_HPOUTR_VOLUME,
                             WM8962_HPOUT_VU, WM8962_HPOUT_VU);
 
+        /* Stereo control for EQ */
+        snd_soc_update_bits(codec, WM8962_EQ1, WM8962_EQ_SHARED_COEFF, 0);
+
         wm8962_add_widgets(codec);
 
         /* Save boards having to disable DMIC when not in use */
@@ -3899,7 +3938,7 @@ static int wm8962_probe(struct snd_soc_codec *codec)
         wm8962_init_beep(codec);
         wm8962_init_gpio(codec);
 
-        if (i2c->irq) {
+        if (wm8962->irq) {
                 if (pdata && pdata->irq_active_low) {
                         trigger = IRQF_TRIGGER_LOW;
                         irq_pol = WM8962_IRQ_POL;
@@ -3911,12 +3950,13 @@ static int wm8962_probe(struct snd_soc_codec *codec)
                 snd_soc_update_bits(codec, WM8962_INTERRUPT_CONTROL,
                                     WM8962_IRQ_POL, irq_pol);
 
-                ret = request_threaded_irq(i2c->irq, NULL, wm8962_irq,
+                ret = request_threaded_irq(wm8962->irq, NULL, wm8962_irq,
                                            trigger | IRQF_ONESHOT,
                                            "wm8962", codec);
                 if (ret != 0) {
                         dev_err(codec->dev, "Failed to request IRQ %d: %d\n",
-                                i2c->irq, ret);
+                                wm8962->irq, ret);
+                        wm8962->irq = 0;
                         /* Non-fatal */
                 } else {
                         /* Enable some IRQs by default */
@@ -3941,12 +3981,10 @@ err:
 static int wm8962_remove(struct snd_soc_codec *codec)
 {
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
-        struct i2c_client *i2c = container_of(codec->dev, struct i2c_client,
-                                              dev);
         int i;
 
-        if (i2c->irq)
-                free_irq(i2c->irq, codec);
+        if (wm8962->irq)
+                free_irq(wm8962->irq, codec);
 
         cancel_delayed_work_sync(&wm8962->mic_work);
 
@@ -3963,7 +4001,6 @@ static int wm8962_remove(struct snd_soc_codec *codec)
 static struct snd_soc_codec_driver soc_codec_dev_wm8962 = {
         .probe =        wm8962_probe,
         .remove =       wm8962_remove,
-        .resume =       wm8962_resume,
         .set_bias_level = wm8962_set_bias_level,
         .reg_cache_size = WM8962_MAX_REGISTER + 1,
         .reg_word_size = sizeof(u16),
@@ -3986,6 +4023,8 @@ static __devinit int wm8962_i2c_probe(struct i2c_client *i2c,
 
         i2c_set_clientdata(i2c, wm8962);
 
+        wm8962->irq = i2c->irq;
+
         ret = snd_soc_register_codec(&i2c->dev,
                                      &soc_codec_dev_wm8962, &wm8962_dai, 1);
         if (ret < 0)