CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/wm9090.c

 /*
  * ALSA SoC WM9090 driver
  *
  * Copyright 2009, 2010 Wolfson Microelectronics
  *
  * 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.
@@ skipping 10 matching lines @@
  */
 
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/device.h>
 #include <linux/i2c.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <sound/initval.h>
 #include <sound/soc.h>
-#include <sound/soc-dapm.h>
 #include <sound/tlv.h>
 #include <sound/wm9090.h>
 
 #include "wm9090.h"
 
 static const u16 wm9090_reg_defaults[] = {
         0x9093,     /* R0   - Software Reset */
         0x0006,     /* R1   - Power Management (1) */
         0x6000,     /* R2   - Power Management (2) */
         0x0000,     /* R3   - Power Management (3) */
@@ skipping 96 matching lines @@
         0x0200,     /* R100 - AGC Control 2 */
 };
 
 /* This struct is used to save the context */
 struct wm9090_priv {
         struct mutex mutex;
         struct wm9090_platform_data pdata;
         void *control_data;
 };
 
-static int wm9090_volatile(unsigned int reg)
+static int wm9090_volatile(struct snd_soc_codec *codec, unsigned int reg)
 {
         switch (reg) {
         case WM9090_SOFTWARE_RESET:
         case WM9090_DC_SERVO_0:
         case WM9090_DC_SERVO_READBACK_0:
         case WM9090_DC_SERVO_READBACK_1:
         case WM9090_DC_SERVO_READBACK_2:
                 return 1;
 
         default:
@@ skipping 276 matching lines @@
         { "MIXOUTR", "IN2B Switch", "IN2B PGA" },
 };
 
 static const struct snd_soc_dapm_route audio_map_in2_diff[] = {
         { "IN2A PGA", NULL, "IN2-" },   
 };
 
 static int wm9090_add_controls(struct snd_soc_codec *codec)
 {
         struct wm9090_priv *wm9090 = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
         int i;
 
-        snd_soc_dapm_new_controls(codec, wm9090_dapm_widgets,
+        snd_soc_dapm_new_controls(dapm, wm9090_dapm_widgets,
                                   ARRAY_SIZE(wm9090_dapm_widgets));
 
-        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+        snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
 
         snd_soc_add_controls(codec, wm9090_controls,
                              ARRAY_SIZE(wm9090_controls));
 
         if (wm9090->pdata.lin1_diff) {
-                snd_soc_dapm_add_routes(codec, audio_map_in1_diff,
+                snd_soc_dapm_add_routes(dapm, audio_map_in1_diff,
                                         ARRAY_SIZE(audio_map_in1_diff));
         } else {
-                snd_soc_dapm_add_routes(codec, audio_map_in1_se,
+                snd_soc_dapm_add_routes(dapm, audio_map_in1_se,
                                         ARRAY_SIZE(audio_map_in1_se));
                 snd_soc_add_controls(codec, wm9090_in1_se_controls,
                                      ARRAY_SIZE(wm9090_in1_se_controls));
         }
 
         if (wm9090->pdata.lin2_diff) {
-                snd_soc_dapm_add_routes(codec, audio_map_in2_diff,
+                snd_soc_dapm_add_routes(dapm, audio_map_in2_diff,
                                         ARRAY_SIZE(audio_map_in2_diff));
         } else {
-                snd_soc_dapm_add_routes(codec, audio_map_in2_se,
+                snd_soc_dapm_add_routes(dapm, audio_map_in2_se,
                                         ARRAY_SIZE(audio_map_in2_se));
                 snd_soc_add_controls(codec, wm9090_in2_se_controls,
                                      ARRAY_SIZE(wm9090_in2_se_controls));
         }
 
         if (wm9090->pdata.agc_ena) {
                 for (i = 0; i < ARRAY_SIZE(wm9090->pdata.agc); i++)
                         snd_soc_write(codec, WM9090_AGC_CONTROL_0 + i,
                                       wm9090->pdata.agc[i]);
                 snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_3,
@@ skipping 26 matching lines @@
                                     WM9090_VMID_ENA);
                 snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_1,
                                     WM9090_BIAS_ENA |
                                     WM9090_VMID_RES_MASK,
                                     WM9090_BIAS_ENA |
                                     1 << WM9090_VMID_RES_SHIFT);
                 msleep(1);  /* Probably an overestimate */
                 break;
 
         case SND_SOC_BIAS_STANDBY:
-                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
                         /* Restore the register cache */
                         for (i = 1; i < codec->driver->reg_cache_size; i++) {
                                 if (reg_cache[i] == wm9090_reg_defaults[i])
                                         continue;
-                                if (wm9090_volatile(i))
+                                if (wm9090_volatile(codec, i))
                                         continue;
 
                                 ret = snd_soc_write(codec, i, reg_cache[i]);
                                 if (ret != 0)
                                         dev_warn(codec->dev,
                                                  "Failed to restore register %d: %d\n",
                                                  i, ret);
                         }
                 }
 
                 /* We keep VMID off during standby since the combination of
                  * ground referenced outputs and class D speaker mean that
                  * latency is not an issue.
                  */
                 snd_soc_update_bits(codec, WM9090_POWER_MANAGEMENT_1,
                                     WM9090_BIAS_ENA | WM9090_VMID_RES_MASK, 0);
                 snd_soc_update_bits(codec, WM9090_ANTIPOP2,
                                     WM9090_VMID_ENA, 0);
                 break;
 
         case SND_SOC_BIAS_OFF:
                 break;
         }
 
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
 
         return 0;
 }
 
 static int wm9090_probe(struct snd_soc_codec *codec)
 {
         struct wm9090_priv *wm9090 = snd_soc_codec_get_drvdata(codec);
-        u16 *reg_cache = codec->reg_cache;
         int ret;
 
         codec->control_data = wm9090->control_data;
         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;
         }
 
         ret = snd_soc_read(codec, WM9090_SOFTWARE_RESET);
         if (ret < 0)
                 return ret;
         if (ret != wm9090_reg_defaults[WM9090_SOFTWARE_RESET]) {
                 dev_err(codec->dev, "Device is not a WM9090, ID=%x\n", ret);
                 return -EINVAL;
         }
 
         ret = snd_soc_write(codec, WM9090_SOFTWARE_RESET, 0);
         if (ret < 0)
                 return ret;
 
         /* Configure some defaults; they will be written out when we
          * bring the bias up.
          */
-        reg_cache[WM9090_IN1_LINE_INPUT_A_VOLUME] |= WM9090_IN1_VU
-                | WM9090_IN1A_ZC;
-        reg_cache[WM9090_IN1_LINE_INPUT_B_VOLUME] |= WM9090_IN1_VU
-                | WM9090_IN1B_ZC;
-        reg_cache[WM9090_IN2_LINE_INPUT_A_VOLUME] |= WM9090_IN2_VU
-                | WM9090_IN2A_ZC;
-        reg_cache[WM9090_IN2_LINE_INPUT_B_VOLUME] |= WM9090_IN2_VU
-                | WM9090_IN2B_ZC;
-        reg_cache[WM9090_SPEAKER_VOLUME_LEFT] |=
-                WM9090_SPKOUT_VU | WM9090_SPKOUTL_ZC;
-        reg_cache[WM9090_LEFT_OUTPUT_VOLUME] |=
-                WM9090_HPOUT1_VU | WM9090_HPOUT1L_ZC;
-        reg_cache[WM9090_RIGHT_OUTPUT_VOLUME] |=
-                WM9090_HPOUT1_VU | WM9090_HPOUT1R_ZC;
+        snd_soc_update_bits(codec, WM9090_IN1_LINE_INPUT_A_VOLUME,
+                            WM9090_IN1_VU | WM9090_IN1A_ZC,
+                            WM9090_IN1_VU | WM9090_IN1A_ZC);
+        snd_soc_update_bits(codec, WM9090_IN1_LINE_INPUT_B_VOLUME,
+                            WM9090_IN1_VU | WM9090_IN1B_ZC,
+                            WM9090_IN1_VU | WM9090_IN1B_ZC);
+        snd_soc_update_bits(codec, WM9090_IN2_LINE_INPUT_A_VOLUME,
+                            WM9090_IN2_VU | WM9090_IN2A_ZC,
+                            WM9090_IN2_VU | WM9090_IN2A_ZC);
+        snd_soc_update_bits(codec, WM9090_IN2_LINE_INPUT_B_VOLUME,
+                            WM9090_IN2_VU | WM9090_IN2B_ZC,
+                            WM9090_IN2_VU | WM9090_IN2B_ZC);
+        snd_soc_update_bits(codec, WM9090_SPEAKER_VOLUME_LEFT,
+                            WM9090_SPKOUT_VU | WM9090_SPKOUTL_ZC,
+                            WM9090_SPKOUT_VU | WM9090_SPKOUTL_ZC);
+        snd_soc_update_bits(codec, WM9090_LEFT_OUTPUT_VOLUME,
+                            WM9090_HPOUT1_VU | WM9090_HPOUT1L_ZC,
+                            WM9090_HPOUT1_VU | WM9090_HPOUT1L_ZC);
+        snd_soc_update_bits(codec, WM9090_RIGHT_OUTPUT_VOLUME,
+                            WM9090_HPOUT1_VU | WM9090_HPOUT1R_ZC,
+                            WM9090_HPOUT1_VU | WM9090_HPOUT1R_ZC);
 
-        reg_cache[WM9090_CLOCKING_1] |= WM9090_TOCLK_ENA;
+        snd_soc_update_bits(codec, WM9090_CLOCKING_1,
+                            WM9090_TOCLK_ENA, WM9090_TOCLK_ENA);
 
         wm9090_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         wm9090_add_controls(codec);
 
         return 0;
 }
 
 #ifdef CONFIG_PM
 static int wm9090_suspend(struct snd_soc_codec *codec, pm_message_t state)
@@ skipping 94 matching lines @@
 
 static void __exit wm9090_exit(void)
 {
         i2c_del_driver(&wm9090_i2c_driver);
 }
 module_exit(wm9090_exit);
 
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_DESCRIPTION("WM9090 ASoC driver");
 MODULE_LICENSE("GPL");