CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/tpa6130a2.c

 /*
  * ALSA SoC Texas Instruments TPA6130A2 headset stereo amplifier driver
  *
  * Copyright (C) Nokia Corporation
  *
  * Author: Peter Ujfalusi <peter.ujfalusi@nokia.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 11 matching lines @@
 
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/device.h>
 #include <linux/i2c.h>
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <sound/tpa6130a2-plat.h>
 #include <sound/soc.h>
-#include <sound/soc-dapm.h>
 #include <sound/tlv.h>
 
 #include "tpa6130a2.h"
 
 static struct i2c_client *tpa6130a2_client;
 
 /* This struct is used to save the context */
 struct tpa6130a2_data {
         struct mutex mutex;
         unsigned char regs[TPA6130A2_CACHEREGNUM];
         struct regulator *supply;
         int power_gpio;
-        unsigned char power_state;
+        u8 power_state:1;
         enum tpa_model id;
 };
 
 static int tpa6130a2_i2c_read(int reg)
 {
         struct tpa6130a2_data *data;
         int val;
 
         BUG_ON(tpa6130a2_client == NULL);
         data = i2c_get_clientdata(tpa6130a2_client);
@@ skipping 54 matching lines @@
 
         for (i = 1; i < TPA6130A2_REG_VERSION; i++) {
                 ret = tpa6130a2_i2c_write(i, data->regs[i]);
                 if (ret < 0)
                         break;
         }
 
         return ret;
 }
 
-static int tpa6130a2_power(int power)
+static int tpa6130a2_power(u8 power)
 {
         struct  tpa6130a2_data *data;
         u8      val;
         int     ret = 0;
 
         BUG_ON(tpa6130a2_client == NULL);
         data = i2c_get_clientdata(tpa6130a2_client);
 
         mutex_lock(&data->mutex);
-        if (power && !data->power_state) {
-                /* Power on */
-                if (data->power_gpio >= 0)
-                        gpio_set_value(data->power_gpio, 1);
+        if (power == data->power_state)
+                goto exit;
 
+        if (power) {
                 ret = regulator_enable(data->supply);
                 if (ret != 0) {
                         dev_err(&tpa6130a2_client->dev,
                                 "Failed to enable supply: %d\n", ret);
                         goto exit;
                 }
+                /* Power on */
+                if (data->power_gpio >= 0)
+                        gpio_set_value(data->power_gpio, 1);
 
                 data->power_state = 1;
                 ret = tpa6130a2_initialize();
                 if (ret < 0) {
                         dev_err(&tpa6130a2_client->dev,
                                 "Failed to initialize chip\n");
                         if (data->power_gpio >= 0)
                                 gpio_set_value(data->power_gpio, 0);
                         regulator_disable(data->supply);
                         data->power_state = 0;
                         goto exit;
                 }
-
-                /* Clear SWS */
-                val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
-                val &= ~TPA6130A2_SWS;
-                tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
-        } else if (!power && data->power_state) {
+        } else {
                 /* set SWS */
                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
                 val |= TPA6130A2_SWS;
                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
 
                 /* Power off */
                 if (data->power_gpio >= 0)
                         gpio_set_value(data->power_gpio, 0);
 
                 ret = regulator_disable(data->supply);
@@ skipping 124 matching lines @@
  */
 static void tpa6130a2_channel_enable(u8 channel, int enable)
 {
         u8      val;
 
         if (enable) {
                 /* Enable channel */
                 /* Enable amplifier */
                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
                 val |= channel;
+                val &= ~TPA6130A2_SWS;
                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
 
                 /* Unmute channel */
                 val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
                 val &= ~channel;
                 tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
         } else {
                 /* Disable channel */
                 /* Mute channel */
                 val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
                 val |= channel;
                 tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
 
                 /* Disable amplifier */
                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
                 val &= ~channel;
                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
         }
 }
 
-static int tpa6130a2_left_event(struct snd_soc_dapm_widget *w,
-                struct snd_kcontrol *kcontrol, int event)
-{
-        switch (event) {
-        case SND_SOC_DAPM_POST_PMU:
-                tpa6130a2_channel_enable(TPA6130A2_HP_EN_L, 1);
-                break;
-        case SND_SOC_DAPM_POST_PMD:
-                tpa6130a2_channel_enable(TPA6130A2_HP_EN_L, 0);
-                break;
-        }
-        return 0;
-}
-
-static int tpa6130a2_right_event(struct snd_soc_dapm_widget *w,
-                struct snd_kcontrol *kcontrol, int event)
-{
-        switch (event) {
-        case SND_SOC_DAPM_POST_PMU:
-                tpa6130a2_channel_enable(TPA6130A2_HP_EN_R, 1);
-                break;
-        case SND_SOC_DAPM_POST_PMD:
-                tpa6130a2_channel_enable(TPA6130A2_HP_EN_R, 0);
-                break;
-        }
-        return 0;
-}
-
-static int tpa6130a2_supply_event(struct snd_soc_dapm_widget *w,
-                struct snd_kcontrol *kcontrol, int event)
+int tpa6130a2_stereo_enable(struct snd_soc_codec *codec, int enable)
 {
         int ret = 0;
+        if (enable) {
+                ret = tpa6130a2_power(1);
+                if (ret < 0)
+                        return ret;
+                tpa6130a2_channel_enable(TPA6130A2_HP_EN_R | TPA6130A2_HP_EN_L,
+                                         1);
+        } else {
+                tpa6130a2_channel_enable(TPA6130A2_HP_EN_R | TPA6130A2_HP_EN_L,
+                                         0);
+                ret = tpa6130a2_power(0);
+        }
 
-        switch (event) {
-        case SND_SOC_DAPM_POST_PMU:
-                ret = tpa6130a2_power(1);
-                break;
-        case SND_SOC_DAPM_POST_PMD:
-                ret = tpa6130a2_power(0);
-                break;
-        }
         return ret;
 }
-
-static const struct snd_soc_dapm_widget tpa6130a2_dapm_widgets[] = {
-        SND_SOC_DAPM_PGA_E("TPA6130A2 Left", SND_SOC_NOPM,
-                        0, 0, NULL, 0, tpa6130a2_left_event,
-                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
-        SND_SOC_DAPM_PGA_E("TPA6130A2 Right", SND_SOC_NOPM,
-                        0, 0, NULL, 0, tpa6130a2_right_event,
-                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
-        SND_SOC_DAPM_SUPPLY("TPA6130A2 Enable", SND_SOC_NOPM,
-                        0, 0, tpa6130a2_supply_event,
-                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
-        /* Outputs */
-        SND_SOC_DAPM_OUTPUT("TPA6130A2 Headphone Left"),
-        SND_SOC_DAPM_OUTPUT("TPA6130A2 Headphone Right"),
-};
-
-static const struct snd_soc_dapm_route audio_map[] = {
-        {"TPA6130A2 Headphone Left", NULL, "TPA6130A2 Left"},
-        {"TPA6130A2 Headphone Right", NULL, "TPA6130A2 Right"},
-
-        {"TPA6130A2 Headphone Left", NULL, "TPA6130A2 Enable"},
-        {"TPA6130A2 Headphone Right", NULL, "TPA6130A2 Enable"},
-};
+EXPORT_SYMBOL_GPL(tpa6130a2_stereo_enable);
 
 int tpa6130a2_add_controls(struct snd_soc_codec *codec)
 {
         struct  tpa6130a2_data *data;
 
         if (tpa6130a2_client == NULL)
                 return -ENODEV;
 
         data = i2c_get_clientdata(tpa6130a2_client);
 
-        snd_soc_dapm_new_controls(codec, tpa6130a2_dapm_widgets,
-                                ARRAY_SIZE(tpa6130a2_dapm_widgets));
-
-        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
-
         if (data->id == TPA6140A2)
                 return snd_soc_add_controls(codec, tpa6140a2_controls,
                                                 ARRAY_SIZE(tpa6140a2_controls));
         else
                 return snd_soc_add_controls(codec, tpa6130a2_controls,
                                                 ARRAY_SIZE(tpa6130a2_controls));
-
 }
 EXPORT_SYMBOL_GPL(tpa6130a2_add_controls);
 
 static int __devinit tpa6130a2_probe(struct i2c_client *client,
                                      const struct i2c_device_id *id)
 {
         struct device *dev;
         struct tpa6130a2_data *data;
         struct tpa6130a2_platform_data *pdata;
         const char *regulator;
@@ skipping 130 matching lines @@
 {
         i2c_del_driver(&tpa6130a2_i2c_driver);
 }
 
 MODULE_AUTHOR("Peter Ujfalusi");
 MODULE_DESCRIPTION("TPA6130A2 Headphone amplifier driver");
 MODULE_LICENSE("GPL");
 
 module_init(tpa6130a2_init);
 module_exit(tpa6130a2_exit);