CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/uda1380.c

 /*
  * uda1380.c - Philips UDA1380 ALSA SoC audio driver
  *
  * 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.
  *
  * Copyright (c) 2007-2009 Philipp Zabel <philipp.zabel@gmail.com>
  *
  * Modified by Richard Purdie <richard@openedhand.com> to fit into SoC
  * codec model.
  *
  * Copyright (c) 2005 Giorgio Padrin <giorgio@mandarinlogiq.org>
  * Copyright 2005 Openedhand Ltd.
  */
 
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/gpio.h>
 #include <linux/delay.h>
 #include <linux/i2c.h>
 #include <linux/workqueue.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/initval.h>
 #include <sound/soc.h>
-#include <sound/soc-dapm.h>
 #include <sound/tlv.h>
 #include <sound/uda1380.h>
 
 #include "uda1380.h"
 
 /* codec private data */
 struct uda1380_priv {
         struct snd_soc_codec *codec;
-        u16 reg_cache[UDA1380_CACHEREGNUM];
         unsigned int dac_clk;
         struct work_struct work;
         void *control_data;
 };
 
 /*
  * uda1380 register cache
  */
 static const u16 uda1380_reg[UDA1380_CACHEREGNUM] = {
         0x0502, 0x0000, 0x0000, 0x3f3f,
@@ skipping 357 matching lines @@
         {"Right ADC", "Line", "Right PGA"},
 
         /* inputs */
         {"Mic LNA", NULL, "VINM"},
         {"Left PGA", NULL, "VINL"},
         {"Right PGA", NULL, "VINR"},
 };
 
 static int uda1380_add_widgets(struct snd_soc_codec *codec)
 {
-        snd_soc_dapm_new_controls(codec, uda1380_dapm_widgets,
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+
+        snd_soc_dapm_new_controls(dapm, uda1380_dapm_widgets,
                                   ARRAY_SIZE(uda1380_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;
 }
 
 static int uda1380_set_dai_fmt_both(struct snd_soc_dai *codec_dai,
                 unsigned int fmt)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         int iface;
 
@@ skipping 165 matching lines @@
         uda1380_write(codec, UDA1380_CLK, clk);
 }
 
 static int uda1380_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
         int pm = uda1380_read_reg_cache(codec, UDA1380_PM);
         int reg;
         struct uda1380_platform_data *pdata = codec->dev->platform_data;
 
-        if (codec->bias_level == level)
+        if (codec->dapm.bias_level == level)
                 return 0;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
         case SND_SOC_BIAS_PREPARE:
                 /* ADC, DAC on */
                 uda1380_write(codec, UDA1380_PM, R02_PON_BIAS | pm);
                 break;
         case SND_SOC_BIAS_STANDBY:
-                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
                         if (gpio_is_valid(pdata->gpio_power)) {
                                 gpio_set_value(pdata->gpio_power, 1);
                                 mdelay(1);
                                 uda1380_reset(codec);
                         }
 
                         uda1380_sync_cache(codec);
                 }
                 uda1380_write(codec, UDA1380_PM, 0x0);
                 break;
         case SND_SOC_BIAS_OFF:
                 if (!gpio_is_valid(pdata->gpio_power))
                         break;
 
                 gpio_set_value(pdata->gpio_power, 0);
 
                 /* Mark mixer regs cache dirty to sync them with
                  * codec regs on power on.
                  */
                 for (reg = UDA1380_MVOL; reg < UDA1380_CACHEREGNUM; reg++)
                         set_bit(reg - 0x10, &uda1380_cache_dirty);
         }
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
         return 0;
 }
 
 #define UDA1380_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
                        SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
                        SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
 
 static struct snd_soc_dai_ops uda1380_dai_ops = {
         .hw_params      = uda1380_pcm_hw_params,
         .shutdown       = uda1380_pcm_shutdown,
@@ skipping 228 matching lines @@
 {
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         i2c_del_driver(&uda1380_i2c_driver);
 #endif
 }
 module_exit(uda1380_exit);
 
 MODULE_AUTHOR("Giorgio Padrin");
 MODULE_DESCRIPTION("Audio support for codec Philips UDA1380");
 MODULE_LICENSE("GPL");