CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/wm_hubs.c

 /*
  * wm_hubs.c  --  WM8993/4 common code
  *
  * Copyright 2009 Wolfson Microelectronics plc
  *
  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  *
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
-#include <sound/soc-dapm.h>
 #include <sound/initval.h>
 #include <sound/tlv.h>
 
 #include "wm8993.h"
 #include "wm_hubs.h"
 
 const DECLARE_TLV_DB_SCALE(wm_hubs_spkmix_tlv, -300, 300, 0);
 EXPORT_SYMBOL_GPL(wm_hubs_spkmix_tlv);
 
 static const DECLARE_TLV_DB_SCALE(inpga_tlv, -1650, 150, 0);
@@ skipping 49 matching lines @@
         if (reg & op)
                 dev_err(codec->dev, "Timed out waiting for DC Servo\n");
 }
 
 /*
  * Startup calibration of the DC servo
  */
 static void calibrate_dc_servo(struct snd_soc_codec *codec)
 {
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
+        s8 offset;
         u16 reg, reg_l, reg_r, dcs_cfg;
 
-        /* Set for 32 series updates */
-        snd_soc_update_bits(codec, WM8993_DC_SERVO_1,
-                            WM8993_DCS_SERIES_NO_01_MASK,
-                            32 << WM8993_DCS_SERIES_NO_01_SHIFT);
-        wait_for_dc_servo(codec,
-                          WM8993_DCS_TRIG_SERIES_0 | WM8993_DCS_TRIG_SERIES_1);
+        /* If we're using a digital only path and have a previously
+         * callibrated DC servo offset stored then use that. */
+        if (hubs->class_w && hubs->class_w_dcs) {
+                dev_dbg(codec->dev, "Using cached DC servo offset %x\n",
+                        hubs->class_w_dcs);
+                snd_soc_write(codec, WM8993_DC_SERVO_3, hubs->class_w_dcs);
+                wait_for_dc_servo(codec,
+                                  WM8993_DCS_TRIG_DAC_WR_0 |
+                                  WM8993_DCS_TRIG_DAC_WR_1);
+                return;
+        }
+
+        /* Devices not using a DCS code correction have startup mode */
+        if (hubs->dcs_codes) {
+                /* Set for 32 series updates */
+                snd_soc_update_bits(codec, WM8993_DC_SERVO_1,
+                                    WM8993_DCS_SERIES_NO_01_MASK,
+                                    32 << WM8993_DCS_SERIES_NO_01_SHIFT);
+                wait_for_dc_servo(codec,
+                                  WM8993_DCS_TRIG_SERIES_0 |
+                                  WM8993_DCS_TRIG_SERIES_1);
+        } else {
+                wait_for_dc_servo(codec,
+                                  WM8993_DCS_TRIG_STARTUP_0 |
+                                  WM8993_DCS_TRIG_STARTUP_1);
+        }
+
+        /* Different chips in the family support different readback
+         * methods.
+         */
+        switch (hubs->dcs_readback_mode) {
+        case 0:
+                reg_l = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_1)
+                        & WM8993_DCS_INTEG_CHAN_0_MASK;
+                reg_r = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_2)
+                        & WM8993_DCS_INTEG_CHAN_1_MASK;
+                break;
+        case 1:
+                reg = snd_soc_read(codec, WM8993_DC_SERVO_3);
+                reg_l = (reg & WM8993_DCS_DAC_WR_VAL_1_MASK)
+                        >> WM8993_DCS_DAC_WR_VAL_1_SHIFT;
+                reg_r = reg & WM8993_DCS_DAC_WR_VAL_0_MASK;
+                break;
+        default:
+                WARN(1, "Unknown DCS readback method\n");
+                break;
+        }
+
+        dev_dbg(codec->dev, "DCS input: %x %x\n", reg_l, reg_r);
 
         /* Apply correction to DC servo result */
         if (hubs->dcs_codes) {
                 dev_dbg(codec->dev, "Applying %d code DC servo correction\n",
                         hubs->dcs_codes);
 
-                /* Different chips in the family support different
-                 * readback methods.
-                 */
-                switch (hubs->dcs_readback_mode) {
-                case 0:
-                        reg_l = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_1)
-                                & WM8993_DCS_INTEG_CHAN_0_MASK;;
-                        reg_r = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_2)
-                                & WM8993_DCS_INTEG_CHAN_1_MASK;
-                        break;
-                case 1:
-                        reg = snd_soc_read(codec, WM8993_DC_SERVO_3);
-                        reg_l = (reg & WM8993_DCS_DAC_WR_VAL_1_MASK)
-                                >> WM8993_DCS_DAC_WR_VAL_1_SHIFT;
-                        reg_r = reg & WM8993_DCS_DAC_WR_VAL_0_MASK;
-                        break;
-                default:
-                        WARN(1, "Unknown DCS readback method\n");
-                        break;
-                }
-
-                dev_dbg(codec->dev, "DCS input: %x %x\n", reg_l, reg_r);
-
                 /* HPOUT1L */
-                if (reg_l + hubs->dcs_codes > 0 &&
-                    reg_l + hubs->dcs_codes < 0xff)
-                        reg_l += hubs->dcs_codes;
-                dcs_cfg = reg_l << WM8993_DCS_DAC_WR_VAL_1_SHIFT;
+                offset = reg_l;
+                offset += hubs->dcs_codes;
+                dcs_cfg = (u8)offset << WM8993_DCS_DAC_WR_VAL_1_SHIFT;
 
                 /* HPOUT1R */
-                if (reg_r + hubs->dcs_codes > 0 &&
-                    reg_r + hubs->dcs_codes < 0xff)
-                        reg_r += hubs->dcs_codes;
-                dcs_cfg |= reg_r;
+                offset = reg_r;
+                offset += hubs->dcs_codes;
+                dcs_cfg |= (u8)offset;
 
                 dev_dbg(codec->dev, "DCS result: %x\n", dcs_cfg);
 
                 /* Do it */
                 snd_soc_write(codec, WM8993_DC_SERVO_3, dcs_cfg);
                 wait_for_dc_servo(codec,
                                   WM8993_DCS_TRIG_DAC_WR_0 |
                                   WM8993_DCS_TRIG_DAC_WR_1);
+        } else {
+                dcs_cfg = reg_l << WM8993_DCS_DAC_WR_VAL_1_SHIFT;
+                dcs_cfg |= reg_r;
         }
+
+        /* Save the callibrated offset if we're in class W mode and
+         * therefore don't have any analogue signal mixed in. */
+        if (hubs->class_w)
+                hubs->class_w_dcs = dcs_cfg;
 }
 
 /*
  * Update the DC servo calibration on gain changes
  */
 static int wm8993_put_dc_servo(struct snd_kcontrol *kcontrol,
                                struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
         int ret;
 
         ret = snd_soc_put_volsw_2r(kcontrol, ucontrol);
 
+        /* Updating the analogue gains invalidates the DC servo cache */
+        hubs->class_w_dcs = 0;
+
         /* If we're applying an offset correction then updating the
          * callibration would be likely to introduce further offsets. */
         if (hubs->dcs_codes)
                 return ret;
 
         /* Only need to do this if the outputs are active */
         if (snd_soc_read(codec, WM8993_POWER_MANAGEMENT_1)
             & (WM8993_HPOUT1L_ENA | WM8993_HPOUT1R_ENA))
                 snd_soc_update_bits(codec,
                                     WM8993_DC_SERVO_0,
@@ skipping 608 matching lines @@
         { "LINEOUT2N Mixer", "Right Output Switch", "Left Output Mixer" },
 
         { "LINEOUT2P Mixer", "Right Output Switch", "Right Output Mixer" },
 
         { "LINEOUT2N Driver", NULL, "LINEOUT2N Mixer" },
         { "LINEOUT2P Driver", NULL, "LINEOUT2P Mixer" },
 };
 
 int wm_hubs_add_analogue_controls(struct snd_soc_codec *codec)
 {
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+
         /* Latch volume update bits & default ZC on */
         snd_soc_update_bits(codec, WM8993_LEFT_LINE_INPUT_1_2_VOLUME,
                             WM8993_IN1_VU, WM8993_IN1_VU);
         snd_soc_update_bits(codec, WM8993_RIGHT_LINE_INPUT_1_2_VOLUME,
                             WM8993_IN1_VU, WM8993_IN1_VU);
         snd_soc_update_bits(codec, WM8993_LEFT_LINE_INPUT_3_4_VOLUME,
                             WM8993_IN2_VU, WM8993_IN2_VU);
         snd_soc_update_bits(codec, WM8993_RIGHT_LINE_INPUT_3_4_VOLUME,
                             WM8993_IN2_VU, WM8993_IN2_VU);
 
         snd_soc_update_bits(codec, WM8993_SPEAKER_VOLUME_RIGHT,
                             WM8993_SPKOUT_VU, WM8993_SPKOUT_VU);
 
         snd_soc_update_bits(codec, WM8993_LEFT_OUTPUT_VOLUME,
                             WM8993_HPOUT1L_ZC, WM8993_HPOUT1L_ZC);
         snd_soc_update_bits(codec, WM8993_RIGHT_OUTPUT_VOLUME,
                             WM8993_HPOUT1_VU | WM8993_HPOUT1R_ZC,
                             WM8993_HPOUT1_VU | WM8993_HPOUT1R_ZC);
 
         snd_soc_update_bits(codec, WM8993_LEFT_OPGA_VOLUME,
                             WM8993_MIXOUTL_ZC, WM8993_MIXOUTL_ZC);
         snd_soc_update_bits(codec, WM8993_RIGHT_OPGA_VOLUME,
                             WM8993_MIXOUTR_ZC | WM8993_MIXOUT_VU,
                             WM8993_MIXOUTR_ZC | WM8993_MIXOUT_VU);
 
         snd_soc_add_controls(codec, analogue_snd_controls,
                              ARRAY_SIZE(analogue_snd_controls));
 
-        snd_soc_dapm_new_controls(codec, analogue_dapm_widgets,
+        snd_soc_dapm_new_controls(dapm, analogue_dapm_widgets,
                                   ARRAY_SIZE(analogue_dapm_widgets));
         return 0;
 }
 EXPORT_SYMBOL_GPL(wm_hubs_add_analogue_controls);
 
 int wm_hubs_add_analogue_routes(struct snd_soc_codec *codec,
                                 int lineout1_diff, int lineout2_diff)
 {
-        snd_soc_dapm_add_routes(codec, analogue_routes,
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+
+        snd_soc_dapm_add_routes(dapm, analogue_routes,
                                 ARRAY_SIZE(analogue_routes));
 
         if (lineout1_diff)
-                snd_soc_dapm_add_routes(codec,
+                snd_soc_dapm_add_routes(dapm,
                                         lineout1_diff_routes,
                                         ARRAY_SIZE(lineout1_diff_routes));
         else
-                snd_soc_dapm_add_routes(codec,
+                snd_soc_dapm_add_routes(dapm,
                                         lineout1_se_routes,
                                         ARRAY_SIZE(lineout1_se_routes));
 
         if (lineout2_diff)
-                snd_soc_dapm_add_routes(codec,
+                snd_soc_dapm_add_routes(dapm,
                                         lineout2_diff_routes,
                                         ARRAY_SIZE(lineout2_diff_routes));
         else
-                snd_soc_dapm_add_routes(codec,
+                snd_soc_dapm_add_routes(dapm,
                                         lineout2_se_routes,
                                         ARRAY_SIZE(lineout2_se_routes));
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(wm_hubs_add_analogue_routes);
 
 int wm_hubs_handle_analogue_pdata(struct snd_soc_codec *codec,
                                   int lineout1_diff, int lineout2_diff,
                                   int lineout1fb, int lineout2fb,
                                   int jd_scthr, int jd_thr, int micbias1_lvl,
                                   int micbias2_lvl)
 {
         if (!lineout1_diff)
                 snd_soc_update_bits(codec, WM8993_LINE_MIXER1,
                                     WM8993_LINEOUT1_MODE,
                                     WM8993_LINEOUT1_MODE);
         if (!lineout2_diff)
                 snd_soc_update_bits(codec, WM8993_LINE_MIXER2,
                                     WM8993_LINEOUT2_MODE,
                                     WM8993_LINEOUT2_MODE);
 
         /* If the line outputs are differential then we aren't presenting
          * VMID as an output and can disable it.
          */
         if (lineout1_diff && lineout2_diff)
-                codec->idle_bias_off = 1;
+                codec->dapm.idle_bias_off = 1;
 
         if (lineout1fb)
                 snd_soc_update_bits(codec, WM8993_ADDITIONAL_CONTROL,
                                     WM8993_LINEOUT1_FB, WM8993_LINEOUT1_FB);
 
         if (lineout2fb)
                 snd_soc_update_bits(codec, WM8993_ADDITIONAL_CONTROL,
                                     WM8993_LINEOUT2_FB, WM8993_LINEOUT2_FB);
 
         snd_soc_update_bits(codec, WM8993_MICBIAS,
                             WM8993_JD_SCTHR_MASK | WM8993_JD_THR_MASK |
                             WM8993_MICB1_LVL | WM8993_MICB2_LVL,
                             jd_scthr << WM8993_JD_SCTHR_SHIFT |
                             jd_thr << WM8993_JD_THR_SHIFT |
                             micbias1_lvl |
                             micbias2_lvl << WM8993_MICB2_LVL_SHIFT);
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(wm_hubs_handle_analogue_pdata);
 
 MODULE_DESCRIPTION("Shared support for Wolfson hubs products");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_LICENSE("GPL");