CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/tlv320aic3x.c

 /*
  * ALSA SoC TLV320AIC3X codec driver
  *
  * Author:      Vladimir Barinov, <vbarinov@embeddedalley.com>
  * Copyright:   (C) 2007 MontaVista Software, Inc., <source@mvista.com>
  *
  * Based on sound/soc/codecs/wm8753.c by Liam Girdwood
  *
  * 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
@@ skipping 28 matching lines @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <linux/platform_device.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/initval.h>
 #include <sound/tlv.h>
 #include <sound/tlv320aic3x.h>
 
 #include "tlv320aic3x.h"
 
 #define AIC3X_NUM_SUPPLIES      4
 static const char *aic3x_supply_names[AIC3X_NUM_SUPPLIES] = {
         "IOVDD",        /* I/O Voltage */
         "DVDD",         /* Digital Core Voltage */
         "AVDD",         /* Analog DAC Voltage */
         "DRVDD",        /* ADC Analog and Output Driver Voltage */
 };
 
+static LIST_HEAD(reset_list);
+
 struct aic3x_priv;
 
 struct aic3x_disable_nb {
         struct notifier_block nb;
         struct aic3x_priv *aic3x;
 };
 
 /* codec private data */
 struct aic3x_priv {
         struct snd_soc_codec *codec;
         struct regulator_bulk_data supplies[AIC3X_NUM_SUPPLIES];
         struct aic3x_disable_nb disable_nb[AIC3X_NUM_SUPPLIES];
         enum snd_soc_control_type control_type;
         struct aic3x_setup_data *setup;
         void *control_data;
         unsigned int sysclk;
+        struct list_head list;
         int master;
         int gpio_reset;
         int power;
 #define AIC3X_MODEL_3X 0
 #define AIC3X_MODEL_33 1
 #define AIC3X_MODEL_3007 2
         u16 model;
 };
 
 /*
@@ skipping 86 matching lines @@
 
         if (invert)
                 val = mask - val;
         val_mask = mask << shift;
         val = val << shift;
 
         mutex_lock(&widget->codec->mutex);
 
         if (snd_soc_test_bits(widget->codec, reg, val_mask, val)) {
                 /* find dapm widget path assoc with kcontrol */
-                list_for_each_entry(path, &widget->codec->dapm_paths, list) {
+                list_for_each_entry(path, &widget->dapm->card->paths, list) {
                         if (path->kcontrol != kcontrol)
                                 continue;
 
                         /* found, now check type */
                         found = 1;
                         if (val)
                                 /* new connection */
                                 path->connect = invert ? 0 : 1;
                         else
                                 /* old connection must be powered down */
                                 path->connect = invert ? 1 : 0;
                         break;
                 }
 
                 if (found)
-                        snd_soc_dapm_sync(widget->codec);
+                        snd_soc_dapm_sync(widget->dapm);
         }
 
         ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
 
         mutex_unlock(&widget->codec->mutex);
         return ret;
 }
 
 static const char *aic3x_left_dac_mux[] = { "DAC_L1", "DAC_L3", "DAC_L2" };
 static const char *aic3x_right_dac_mux[] = { "DAC_R1", "DAC_R3", "DAC_R2" };
@@ skipping 568 matching lines @@
         /* Class-D outputs */
         {"Left Class-D Out", NULL, "Left Line Out"},
         {"Right Class-D Out", NULL, "Left Line Out"},
         {"SPOP", NULL, "Left Class-D Out"},
         {"SPOM", NULL, "Right Class-D Out"},
 };
 
 static int aic3x_add_widgets(struct snd_soc_codec *codec)
 {
         struct aic3x_priv *aic3x = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
-        snd_soc_dapm_new_controls(codec, aic3x_dapm_widgets,
+        snd_soc_dapm_new_controls(dapm, aic3x_dapm_widgets,
                                   ARRAY_SIZE(aic3x_dapm_widgets));
 
         /* set up audio path interconnects */
-        snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
+        snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon));
 
         if (aic3x->model == AIC3X_MODEL_3007) {
-                snd_soc_dapm_new_controls(codec, aic3007_dapm_widgets,
+                snd_soc_dapm_new_controls(dapm, aic3007_dapm_widgets,
                         ARRAY_SIZE(aic3007_dapm_widgets));
-                snd_soc_dapm_add_routes(codec, intercon_3007, ARRAY_SIZE(intercon_3007));
+                snd_soc_dapm_add_routes(dapm, intercon_3007,
+                                        ARRAY_SIZE(intercon_3007));
         }
 
         return 0;
 }
 
 static int aic3x_hw_params(struct snd_pcm_substream *substream,
                            struct snd_pcm_hw_params *params,
                            struct snd_soc_dai *dai)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
@@ skipping 256 matching lines @@
 {
         struct aic3x_disable_nb *disable_nb =
                 container_of(nb, struct aic3x_disable_nb, nb);
         struct aic3x_priv *aic3x = disable_nb->aic3x;
 
         if (event & REGULATOR_EVENT_DISABLE) {
                 /*
                  * Put codec to reset and require cache sync as at least one
                  * of the supplies was disabled
                  */
-                if (aic3x->gpio_reset >= 0)
+                if (gpio_is_valid(aic3x->gpio_reset))
                         gpio_set_value(aic3x->gpio_reset, 0);
                 aic3x->codec->cache_sync = 1;
         }
 
         return 0;
 }
 
 static int aic3x_set_power(struct snd_soc_codec *codec, int power)
 {
         struct aic3x_priv *aic3x = snd_soc_codec_get_drvdata(codec);
         int i, ret;
         u8 *cache = codec->reg_cache;
 
         if (power) {
                 ret = regulator_bulk_enable(ARRAY_SIZE(aic3x->supplies),
                                             aic3x->supplies);
                 if (ret)
                         goto out;
                 aic3x->power = 1;
                 /*
                  * Reset release and cache sync is necessary only if some
                  * supply was off or if there were cached writes
                  */
                 if (!codec->cache_sync)
                         goto out;
 
-                if (aic3x->gpio_reset >= 0) {
+                if (gpio_is_valid(aic3x->gpio_reset)) {
                         udelay(1);
                         gpio_set_value(aic3x->gpio_reset, 1);
                 }
 
                 /* Sync reg_cache with the hardware */
                 codec->cache_only = 0;
                 for (i = 0; i < ARRAY_SIZE(aic3x_reg); i++)
                         snd_soc_write(codec, i, cache[i]);
                 if (aic3x->model == AIC3X_MODEL_3007)
                         aic3x_init_3007(codec);
@@ skipping 12 matching lines @@
 static int aic3x_set_bias_level(struct snd_soc_codec *codec,
                                 enum snd_soc_bias_level level)
 {
         struct aic3x_priv *aic3x = snd_soc_codec_get_drvdata(codec);
         u8 reg;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
         case SND_SOC_BIAS_PREPARE:
-                if (codec->bias_level == SND_SOC_BIAS_STANDBY &&
+                if (codec->dapm.bias_level == SND_SOC_BIAS_STANDBY &&
                     aic3x->master) {
                         /* enable pll */
                         reg = snd_soc_read(codec, AIC3X_PLL_PROGA_REG);
                         snd_soc_write(codec, AIC3X_PLL_PROGA_REG,
                                       reg | PLL_ENABLE);
                 }
                 break;
         case SND_SOC_BIAS_STANDBY:
                 if (!aic3x->power)
                         aic3x_set_power(codec, 1);
-                if (codec->bias_level == SND_SOC_BIAS_PREPARE &&
+                if (codec->dapm.bias_level == SND_SOC_BIAS_PREPARE &&
                     aic3x->master) {
                         /* disable pll */
                         reg = snd_soc_read(codec, AIC3X_PLL_PROGA_REG);
                         snd_soc_write(codec, AIC3X_PLL_PROGA_REG,
                                       reg & ~PLL_ENABLE);
                 }
                 break;
         case SND_SOC_BIAS_OFF:
                 if (aic3x->power)
                         aic3x_set_power(codec, 0);
                 break;
         }
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
 
         return 0;
 }
 
 void aic3x_set_gpio(struct snd_soc_codec *codec, int gpio, int state)
 {
         u8 reg = gpio ? AIC3X_GPIO2_REG : AIC3X_GPIO1_REG;
         u8 bit = gpio ? 3: 0;
         u8 val = snd_soc_read(codec, reg) & ~(1 << bit);
         snd_soc_write(codec, reg, val | (!!state << bit));
@@ skipping 164 matching lines @@
         snd_soc_write(codec, LINE2R_2_MONOLOPM_VOL, DEFAULT_VOL);
 
         if (aic3x->model == AIC3X_MODEL_3007) {
                 aic3x_init_3007(codec);
                 snd_soc_write(codec, CLASSD_CTRL, 0);
         }
 
         return 0;
 }
 
+static bool aic3x_is_shared_reset(struct aic3x_priv *aic3x)
+{
+        struct aic3x_priv *a;
+
+        list_for_each_entry(a, &reset_list, list) {
+                if (gpio_is_valid(aic3x->gpio_reset) &&
+                    aic3x->gpio_reset == a->gpio_reset)
+                        return true;
+        }
+
+        return false;
+}
+
 static int aic3x_probe(struct snd_soc_codec *codec)
 {
         struct aic3x_priv *aic3x = snd_soc_codec_get_drvdata(codec);
         int ret, i;
 
+        INIT_LIST_HEAD(&aic3x->list);
         codec->control_data = aic3x->control_data;
         aic3x->codec = codec;
-        codec->idle_bias_off = 1;
+        codec->dapm.idle_bias_off = 1;
 
         ret = snd_soc_codec_set_cache_io(codec, 8, 8, aic3x->control_type);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
         }
 
-        if (aic3x->gpio_reset >= 0) {
+        if (gpio_is_valid(aic3x->gpio_reset) &&
+            !aic3x_is_shared_reset(aic3x)) {
                 ret = gpio_request(aic3x->gpio_reset, "tlv320aic3x reset");
                 if (ret != 0)
                         goto err_gpio;
                 gpio_direction_output(aic3x->gpio_reset, 0);
         }
 
         for (i = 0; i < ARRAY_SIZE(aic3x->supplies); i++)
                 aic3x->supplies[i].supply = aic3x_supply_names[i];
 
         ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(aic3x->supplies),
@@ skipping 25 matching lines @@
                 snd_soc_write(codec, AIC3X_GPIO2_REG,
                               (aic3x->setup->gpio_func[1] & 0xf) << 4);
         }
 
         snd_soc_add_controls(codec, aic3x_snd_controls,
                              ARRAY_SIZE(aic3x_snd_controls));
         if (aic3x->model == AIC3X_MODEL_3007)
                 snd_soc_add_controls(codec, &aic3x_classd_amp_gain_ctrl, 1);
 
         aic3x_add_widgets(codec);
+        list_add(&aic3x->list, &reset_list);
 
         return 0;
 
 err_notif:
         while (i--)
                 regulator_unregister_notifier(aic3x->supplies[i].consumer,
                                               &aic3x->disable_nb[i].nb);
         regulator_bulk_free(ARRAY_SIZE(aic3x->supplies), aic3x->supplies);
 err_get:
-        if (aic3x->gpio_reset >= 0)
+        if (gpio_is_valid(aic3x->gpio_reset) &&
+            !aic3x_is_shared_reset(aic3x))
                 gpio_free(aic3x->gpio_reset);
 err_gpio:
-        kfree(aic3x);
         return ret;
 }
 
 static int aic3x_remove(struct snd_soc_codec *codec)
 {
         struct aic3x_priv *aic3x = snd_soc_codec_get_drvdata(codec);
         int i;
 
         aic3x_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        if (aic3x->gpio_reset >= 0) {
+        list_del(&aic3x->list);
+        if (gpio_is_valid(aic3x->gpio_reset) &&
+            !aic3x_is_shared_reset(aic3x)) {
                 gpio_set_value(aic3x->gpio_reset, 0);
                 gpio_free(aic3x->gpio_reset);
         }
         for (i = 0; i < ARRAY_SIZE(aic3x->supplies); i++)
                 regulator_unregister_notifier(aic3x->supplies[i].consumer,
                                               &aic3x->disable_nb[i].nb);
         regulator_bulk_free(ARRAY_SIZE(aic3x->supplies), aic3x->supplies);
 
         return 0;
 }
@@ skipping 75 matching lines @@
 /* machine i2c codec control layer */
 static struct i2c_driver aic3x_i2c_driver = {
         .driver = {
                 .name = "tlv320aic3x-codec",
                 .owner = THIS_MODULE,
         },
         .probe  = aic3x_i2c_probe,
         .remove = aic3x_i2c_remove,
         .id_table = aic3x_i2c_id,
 };
-
-static inline void aic3x_i2c_init(void)
-{
-        int ret;
-
-        ret = i2c_add_driver(&aic3x_i2c_driver);
-        if (ret)
-                printk(KERN_ERR "%s: error regsitering i2c driver, %d\n",
-                       __func__, ret);
-}
-
-static inline void aic3x_i2c_exit(void)
-{
-        i2c_del_driver(&aic3x_i2c_driver);
-}
 #endif
 
 static int __init aic3x_modinit(void)
 {
         int ret = 0;
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         ret = i2c_add_driver(&aic3x_i2c_driver);
         if (ret != 0) {
                 printk(KERN_ERR "Failed to register TLV320AIC3x I2C driver: %d\n",
                        ret);
         }
 #endif
         return ret;
 }
 module_init(aic3x_modinit);
 
 static void __exit aic3x_exit(void)
 {
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         i2c_del_driver(&aic3x_i2c_driver);
 #endif
 }
 module_exit(aic3x_exit);
 
 MODULE_DESCRIPTION("ASoC TLV320AIC3X codec driver");
 MODULE_AUTHOR("Vladimir Barinov");
 MODULE_LICENSE("GPL");