CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/wm8993.c

 /*
  * wm8993.c -- WM8993 ALSA SoC audio driver
  *
  * Copyright 2009, 2010 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/regulator/consumer.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/tlv.h>
 #include <sound/soc.h>
-#include <sound/soc-dapm.h>
 #include <sound/initval.h>
 #include <sound/wm8993.h>
 
 #include "wm8993.h"
 #include "wm_hubs.h"
 
 #define WM8993_NUM_SUPPLIES 6
 static const char *wm8993_supply_names[WM8993_NUM_SUPPLIES] = {
         "DCVDD",
         "DBVDD",
@@ skipping 181 matching lines @@
         { 160, 10 },
         { 220, 11 },
         { 240, 12 },
         { 320, 13 },
         { 440, 14 },
         { 480, 15 },
 };
 
 struct wm8993_priv {
         struct wm_hubs_data hubs_data;
-        u16 reg_cache[WM8993_REGISTER_COUNT];
         struct regulator_bulk_data supplies[WM8993_NUM_SUPPLIES];
         struct wm8993_platform_data pdata;
         enum snd_soc_control_type control_type;
         int master;
         int sysclk_source;
         int tdm_slots;
         int tdm_width;
         unsigned int mclk_rate;
         unsigned int sysclk_rate;
         unsigned int fs;
         unsigned int bclk;
         int class_w_users;
         unsigned int fll_fref;
         unsigned int fll_fout;
         int fll_src;
 };
 
-static int wm8993_volatile(unsigned int reg)
+static int wm8993_volatile(struct snd_soc_codec *codec, unsigned int reg)
 {
         switch (reg) {
         case WM8993_SOFTWARE_RESET:
         case WM8993_DC_SERVO_0:
         case WM8993_DC_SERVO_READBACK_0:
         case WM8993_DC_SERVO_READBACK_1:
         case WM8993_DC_SERVO_READBACK_2:
                 return 1;
         default:
                 return 0;
@@ skipping 470 matching lines @@
         /* Turn it off if we're using the main output mixer */
         if (ucontrol->value.integer.value[0] == 0) {
                 if (wm8993->class_w_users == 0) {
                         dev_dbg(codec->dev, "Disabling Class W\n");
                         snd_soc_update_bits(codec, WM8993_CLASS_W_0,
                                             WM8993_CP_DYN_FREQ |
                                             WM8993_CP_DYN_V,
                                             0);
                 }
                 wm8993->class_w_users++;
+                wm8993->hubs_data.class_w = true;
         }
 
         /* Implement the change */
         ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
 
         /* Enable it if we're using the direct DAC path */
         if (ucontrol->value.integer.value[0] == 1) {
                 if (wm8993->class_w_users == 1) {
                         dev_dbg(codec->dev, "Enabling Class W\n");
                         snd_soc_update_bits(codec, WM8993_CLASS_W_0,
                                             WM8993_CP_DYN_FREQ |
                                             WM8993_CP_DYN_V,
                                             WM8993_CP_DYN_FREQ |
                                             WM8993_CP_DYN_V);
                 }
                 wm8993->class_w_users--;
+                wm8993->hubs_data.class_w = false;
         }
 
         dev_dbg(codec->dev, "Indirect DAC use count now %d\n",
                 wm8993->class_w_users);
 
         return ret;
 }
 
 #define SOC_DAPM_ENUM_W(xname, xenum) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
@@ skipping 197 matching lines @@
         case SND_SOC_BIAS_ON:
         case SND_SOC_BIAS_PREPARE:
                 /* VMID=2*40k */
                 snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
                                     WM8993_VMID_SEL_MASK, 0x2);
                 snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_2,
                                     WM8993_TSHUT_ENA, WM8993_TSHUT_ENA);
                 break;
 
         case SND_SOC_BIAS_STANDBY:
-                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
                         ret = regulator_bulk_enable(ARRAY_SIZE(wm8993->supplies),
                                                     wm8993->supplies);
                         if (ret != 0)
                                 return ret;
 
                         wm8993_cache_restore(codec);
 
                         /* Tune DC servo configuration */
                         snd_soc_write(codec, 0x44, 3);
                         snd_soc_write(codec, 0x56, 3);
@@ skipping 40 matching lines @@
                 break;
 
         case SND_SOC_BIAS_OFF:
                 snd_soc_update_bits(codec, WM8993_ANTIPOP1,
                                     WM8993_LINEOUT_VMID_BUF_ENA, 0);
 
                 snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
                                     WM8993_VMID_SEL_MASK | WM8993_BIAS_ENA,
                                     0);
 
+                snd_soc_update_bits(codec, WM8993_ANTIPOP2,
+                                    WM8993_STARTUP_BIAS_ENA |
+                                    WM8993_VMID_BUF_ENA |
+                                    WM8993_VMID_RAMP_MASK |
+                                    WM8993_BIAS_SRC, 0);
+
 #ifdef CONFIG_REGULATOR
                /* Post 2.6.34 we will be able to get a callback when
                 * the regulators are disabled which we can use but
                 * for now just assume that the power will be cut if
                 * the regulator API is in use.
                 */
                 codec->cache_sync = 1;
 #endif
 
                 regulator_bulk_disable(ARRAY_SIZE(wm8993->supplies),
                                        wm8993->supplies);
                 break;
         }
 
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
 
         return 0;
 }
 
 static int wm8993_set_sysclk(struct snd_soc_dai *codec_dai,
                              int clk_id, unsigned int freq, int dir)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec);
 
@@ skipping 161 matching lines @@
         ret = configure_clock(codec);
         if (ret != 0)
                 return ret;
 
         /* Select nearest CLK_SYS_RATE */
         best = 0;
         best_val = abs((wm8993->sysclk_rate / clk_sys_rates[0].ratio)
                        - wm8993->fs);
         for (i = 1; i < ARRAY_SIZE(clk_sys_rates); i++) {
                 cur_val = abs((wm8993->sysclk_rate /
-                               clk_sys_rates[i].ratio) - wm8993->fs);;
+                               clk_sys_rates[i].ratio) - wm8993->fs);
                 if (cur_val < best_val) {
                         best = i;
                         best_val = cur_val;
                 }
         }
         dev_dbg(codec->dev, "Selected CLK_SYS_RATIO of %d\n",
                 clk_sys_rates[best].ratio);
         clocking3 |= (clk_sys_rates[best].clk_sys_rate
                       << WM8993_CLK_SYS_RATE_SHIFT);
 
@@ skipping 176 matching lines @@
                  .rates = WM8993_RATES,
                  .formats = WM8993_FORMATS,
          },
         .ops = &wm8993_ops,
         .symmetric_rates = 1,
 };
 
 static int wm8993_probe(struct snd_soc_codec *codec)
 {
         struct wm8993_priv *wm8993 = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
         int ret, i, val;
 
         wm8993->hubs_data.hp_startup_mode = 1;
         wm8993->hubs_data.dcs_codes = -2;
 
         ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
         }
@@ skipping 61 matching lines @@
         snd_soc_add_controls(codec, wm8993_snd_controls,
                              ARRAY_SIZE(wm8993_snd_controls));
         if (wm8993->pdata.num_retune_configs != 0) {
                 dev_dbg(codec->dev, "Using ReTune Mobile\n");
         } else {
                 dev_dbg(codec->dev, "No ReTune Mobile, using normal EQ\n");
                 snd_soc_add_controls(codec, wm8993_eq_controls,
                                      ARRAY_SIZE(wm8993_eq_controls));
         }
 
-        snd_soc_dapm_new_controls(codec, wm8993_dapm_widgets,
+        snd_soc_dapm_new_controls(dapm, wm8993_dapm_widgets,
                                   ARRAY_SIZE(wm8993_dapm_widgets));
         wm_hubs_add_analogue_controls(codec);
 
-        snd_soc_dapm_add_routes(codec, routes, ARRAY_SIZE(routes));
+        snd_soc_dapm_add_routes(dapm, routes, ARRAY_SIZE(routes));
         wm_hubs_add_analogue_routes(codec, wm8993->pdata.lineout1_diff,
                                     wm8993->pdata.lineout2_diff);
 
         return 0;
 
 err_enable:
         regulator_bulk_disable(ARRAY_SIZE(wm8993->supplies), wm8993->supplies);
 err_get:
         regulator_bulk_free(ARRAY_SIZE(wm8993->supplies), wm8993->supplies);
         return ret;
@@ skipping 134 matching lines @@
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         i2c_del_driver(&wm8993_i2c_driver);
 #endif
 }
 module_exit(wm8993_exit);
 
 
 MODULE_DESCRIPTION("ASoC WM8993 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_LICENSE("GPL");