CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/wm8580.c

 /*
  * wm8580.c  --  WM8580 ALSA Soc Audio driver
  *
  * Copyright 2008, 2009 Wolfson Microelectronics PLC.
  *
  *  This program is free software; you can redistribute  it and/or modify it
  *  under  the terms of  the GNU General  Public License as published by the
  *  Free Software Foundation;  either version 2 of the  License, or (at your
  *  option) any later version.
  *
@@ skipping 13 matching lines @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.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/tlv.h>
 #include <sound/initval.h>
 #include <asm/div64.h>
 
 #include "wm8580.h"
 
 /* WM8580 register space */
 #define WM8580_PLLA1                         0x00
 #define WM8580_PLLA2                         0x01
 #define WM8580_PLLA3                         0x02
@@ skipping 139 matching lines @@
 static const char *wm8580_supply_names[WM8580_NUM_SUPPLIES] = {
         "AVDD",
         "DVDD",
         "PVDD",
 };
 
 /* codec private data */
 struct wm8580_priv {
         enum snd_soc_control_type control_type;
         struct regulator_bulk_data supplies[WM8580_NUM_SUPPLIES];
-        u16 reg_cache[WM8580_MAX_REGISTER + 1];
         struct pll_state a;
         struct pll_state b;
         int sysclk[2];
 };
 
 static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
 
 static int wm8580_out_vu(struct snd_kcontrol *kcontrol,
                          struct snd_ctl_elem_value *ucontrol)
 {
@@ skipping 90 matching lines @@
 
         { "VOUT3L", NULL, "DAC3" },
         { "VOUT3R", NULL, "DAC3" },
 
         { "ADC", NULL, "AINL" },
         { "ADC", NULL, "AINR" },
 };
 
 static int wm8580_add_widgets(struct snd_soc_codec *codec)
 {
-        snd_soc_dapm_new_controls(codec, wm8580_dapm_widgets,
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+
+        snd_soc_dapm_new_controls(dapm, wm8580_dapm_widgets,
                                   ARRAY_SIZE(wm8580_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));
 
         return 0;
 }
 
 /* PLL divisors */
 struct _pll_div {
         u32 prescale:1;
         u32 postscale:1;
         u32 freqmode:2;
         u32 n:4;
@@ skipping 181 matching lines @@
                 break;
         case SNDRV_PCM_FORMAT_S32_LE:
                 paifa |= 0x0;
                 paifb |= WM8580_AIF_LENGTH_32;
                 break;
         default:
                 return -EINVAL;
         }
 
         /* Look up the SYSCLK ratio; accept only exact matches */
-        ratio = wm8580->sysclk[dai->id] / params_rate(params);
+        ratio = wm8580->sysclk[dai->driver->id] / params_rate(params);
         for (i = 0; i < ARRAY_SIZE(wm8580_sysclk_ratios); i++)
                 if (ratio == wm8580_sysclk_ratios[i])
                         break;
         if (i == ARRAY_SIZE(wm8580_sysclk_ratios)) {
                 dev_err(codec->dev, "Invalid clock ratio %d/%d\n",
-                        wm8580->sysclk[dai->id], params_rate(params));
+                        wm8580->sysclk[dai->driver->id], params_rate(params));
                 return -EINVAL;
         }
         paifa |= i;
         dev_dbg(codec->dev, "Running at %dfs with %dHz clock\n",
                 wm8580_sysclk_ratios[i], wm8580->sysclk[dai->driver->id]);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 switch (ratio) {
                 case 128:
                 case 192:
@@ skipping 182 matching lines @@
                 sel_shift = 2;
                 break;
 
         default:
                 BUG_ON("Unknown DAI driver ID\n");
                 return -EINVAL;
         }
 
         switch (clk_id) {
         case WM8580_CLKSRC_ADCMCLK:
-                if (dai->id != WM8580_DAI_PAIFTX)
+                if (dai->driver->id != WM8580_DAI_PAIFTX)
                         return -EINVAL;
                 sel = 0 << sel_shift;
                 break;
         case WM8580_CLKSRC_PLLA:
                 sel = 1 << sel_shift;
                 break;
         case WM8580_CLKSRC_PLLB:
                 sel = 2 << sel_shift;
                 break;
         case WM8580_CLKSRC_MCLK:
                 sel = 3 << sel_shift;
                 break;
         default:
                 dev_err(codec->dev, "Unknown clock %d\n", clk_id);
                 return -EINVAL;
         }
 
         /* We really should validate PLL settings but not yet */
-        wm8580->sysclk[dai->id] = freq;
+        wm8580->sysclk[dai->driver->id] = freq;
 
         return snd_soc_update_bits(codec, WM8580_CLKSEL, sel_mask, sel);
 }
 
 static int wm8580_digital_mute(struct snd_soc_dai *codec_dai, int mute)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         unsigned int reg;
 
         reg = snd_soc_read(codec, WM8580_DAC_CONTROL5);
@@ skipping 11 matching lines @@
 static int wm8580_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
         u16 reg;
         switch (level) {
         case SND_SOC_BIAS_ON:
         case SND_SOC_BIAS_PREPARE:
                 break;
 
         case SND_SOC_BIAS_STANDBY:
-                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
                         /* Power up and get individual control of the DACs */
                         reg = snd_soc_read(codec, WM8580_PWRDN1);
                         reg &= ~(WM8580_PWRDN1_PWDN | WM8580_PWRDN1_ALLDACPD);
                         snd_soc_write(codec, WM8580_PWRDN1, reg);
 
                         /* Make VMID high impedence */
                         reg = snd_soc_read(codec,  WM8580_ADC_CONTROL1);
                         reg &= ~0x100;
                         snd_soc_write(codec, WM8580_ADC_CONTROL1, reg);
                 }
                 break;
 
         case SND_SOC_BIAS_OFF:
                 reg = snd_soc_read(codec, WM8580_PWRDN1);
                 snd_soc_write(codec, WM8580_PWRDN1, reg | WM8580_PWRDN1_PWDN);
                 break;
         }
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
         return 0;
 }
 
 #define WM8580_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
                         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
 
 static struct snd_soc_dai_ops wm8580_dai_ops_playback = {
         .set_sysclk     = wm8580_set_sysclk,
         .hw_params      = wm8580_paif_hw_params,
         .set_fmt        = wm8580_set_paif_dai_fmt,
@@ skipping 99 matching lines @@
 
         return 0;
 }
 
 static struct snd_soc_codec_driver soc_codec_dev_wm8580 = {
         .probe =        wm8580_probe,
         .remove =       wm8580_remove,
         .set_bias_level = wm8580_set_bias_level,
         .reg_cache_size = ARRAY_SIZE(wm8580_reg),
         .reg_word_size = sizeof(u16),
-        .reg_cache_default = &wm8580_reg,
+        .reg_cache_default = wm8580_reg,
 };
 
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 static int wm8580_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
         struct wm8580_priv *wm8580;
         int ret;
 
         wm8580 = kzalloc(sizeof(struct wm8580_priv), GFP_KERNEL);
@@ skipping 53 matching lines @@
 {
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         i2c_del_driver(&wm8580_i2c_driver);
 #endif
 }
 module_exit(wm8580_exit);
 
 MODULE_DESCRIPTION("ASoC WM8580 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_LICENSE("GPL");