CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/wm8962.c

 /*
  * wm8962.c  --  WM8962 ALSA SoC Audio driver
  *
  * Copyright 2010 Wolfson Microelectronics plc
  *
  * 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
@@ skipping 11 matching lines @@
 #include <linux/input.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <sound/core.h>
 #include <sound/jack.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/wm8962.h>
+#include <trace/events/asoc.h>
 
 #include "wm8962.h"
 
 #define WM8962_NUM_SUPPLIES 8
 static const char *wm8962_supply_names[WM8962_NUM_SUPPLIES] = {
         "DCVDD",
         "DBVDD",
         "AVDD",
         "CPVDD",
         "MICVDD",
@@ skipping 1885 matching lines @@
         [21132] = { 0x00FF, 0x00FF, 0x0000 }, /* R21132 - VSS_XTS29_1 */
         [21133] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21133 - VSS_XTS29_0 */
         [21134] = { 0x00FF, 0x00FF, 0x0000 }, /* R21134 - VSS_XTS30_1 */
         [21135] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21135 - VSS_XTS30_0 */
         [21136] = { 0x00FF, 0x00FF, 0x0000 }, /* R21136 - VSS_XTS31_1 */
         [21137] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21137 - VSS_XTS31_0 */
         [21138] = { 0x00FF, 0x00FF, 0x0000 }, /* R21138 - VSS_XTS32_1 */
         [21139] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21139 - VSS_XTS32_0 */
 };
 
-static int wm8962_volatile_register(unsigned int reg)
+static int wm8962_volatile_register(struct snd_soc_codec *codec, unsigned int reg)
 {
         if (wm8962_reg_access[reg].vol)
                 return 1;
         else
                 return 0;
 }
 
-static int wm8962_readable_register(unsigned int reg)
+static int wm8962_readable_register(struct snd_soc_codec *codec, unsigned int reg)
 {
         if (wm8962_reg_access[reg].read)
                 return 1;
         else
                 return 0;
 }
 
 static int wm8962_reset(struct snd_soc_codec *codec)
 {
-        return snd_soc_write(codec, WM8962_SOFTWARE_RESET, 0);
+        return snd_soc_write(codec, WM8962_SOFTWARE_RESET, 0x6243);
 }
 
 static const DECLARE_TLV_DB_SCALE(inpga_tlv, -2325, 75, 0);
 static const DECLARE_TLV_DB_SCALE(mixin_tlv, -1500, 300, 0);
 static const unsigned int mixinpga_tlv[] = {
         TLV_DB_RANGE_HEAD(7),
         0, 1, TLV_DB_SCALE_ITEM(0, 600, 0),
         2, 2, TLV_DB_SCALE_ITEM(1300, 1300, 0),
         3, 4, TLV_DB_SCALE_ITEM(1800, 200, 0),
         5, 5, TLV_DB_SCALE_ITEM(2400, 0, 0),
@@ skipping 700 matching lines @@
         { "SPKOUTR Output", NULL, "SYSCLK" },
         { "SPKOUTR Output", NULL, "TOCLK" },
 
         { "SPKOUTL", NULL, "SPKOUTL Output" },
         { "SPKOUTR", NULL, "SPKOUTR Output" },
 };
 
 static int wm8962_add_widgets(struct snd_soc_codec *codec)
 {
         struct wm8962_pdata *pdata = dev_get_platdata(codec->dev);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
         snd_soc_add_controls(codec, wm8962_snd_controls,
                              ARRAY_SIZE(wm8962_snd_controls));
         if (pdata && pdata->spk_mono)
                 snd_soc_add_controls(codec, wm8962_spk_mono_controls,
                                      ARRAY_SIZE(wm8962_spk_mono_controls));
         else
                 snd_soc_add_controls(codec, wm8962_spk_stereo_controls,
                                      ARRAY_SIZE(wm8962_spk_stereo_controls));
 
 
-        snd_soc_dapm_new_controls(codec, wm8962_dapm_widgets,
+        snd_soc_dapm_new_controls(dapm, wm8962_dapm_widgets,
                                   ARRAY_SIZE(wm8962_dapm_widgets));
         if (pdata && pdata->spk_mono)
-                snd_soc_dapm_new_controls(codec, wm8962_dapm_spk_mono_widgets,
+                snd_soc_dapm_new_controls(dapm, wm8962_dapm_spk_mono_widgets,
                                           ARRAY_SIZE(wm8962_dapm_spk_mono_widgets));
         else
-                snd_soc_dapm_new_controls(codec, wm8962_dapm_spk_stereo_widgets,
+                snd_soc_dapm_new_controls(dapm, wm8962_dapm_spk_stereo_widgets,
                                           ARRAY_SIZE(wm8962_dapm_spk_stereo_widgets));
 
-        snd_soc_dapm_add_routes(codec, wm8962_intercon,
+        snd_soc_dapm_add_routes(dapm, wm8962_intercon,
                                 ARRAY_SIZE(wm8962_intercon));
         if (pdata && pdata->spk_mono)
-                snd_soc_dapm_add_routes(codec, wm8962_spk_mono_intercon,
+                snd_soc_dapm_add_routes(dapm, wm8962_spk_mono_intercon,
                                         ARRAY_SIZE(wm8962_spk_mono_intercon));
         else
-                snd_soc_dapm_add_routes(codec, wm8962_spk_stereo_intercon,
+                snd_soc_dapm_add_routes(dapm, wm8962_spk_stereo_intercon,
                                         ARRAY_SIZE(wm8962_spk_stereo_intercon));
 
 
-        snd_soc_dapm_disable_pin(codec, "Beep");
+        snd_soc_dapm_disable_pin(dapm, "Beep");
 
         return 0;
 }
 
 static void wm8962_sync_cache(struct snd_soc_codec *codec)
 {
         u16 *reg_cache = codec->reg_cache;
         int i;
 
         if (!codec->cache_sync)
@@ skipping 86 matching lines @@
         snd_soc_update_bits(codec, WM8962_AUDIO_INTERFACE_2,
                             WM8962_AIF_RATE_MASK, aif2);
 }
 
 static int wm8962_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
-        if (level == codec->bias_level)
+        if (level == codec->dapm.bias_level)
                 return 0;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
 
         case SND_SOC_BIAS_PREPARE:
                 /* VMID 2*50k */
                 snd_soc_update_bits(codec, WM8962_PWR_MGMT_1,
                                     WM8962_VMID_SEL_MASK, 0x80);
                 break;
 
         case SND_SOC_BIAS_STANDBY:
-                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
                         ret = regulator_bulk_enable(ARRAY_SIZE(wm8962->supplies),
                                                     wm8962->supplies);
                         if (ret != 0) {
                                 dev_err(codec->dev,
                                         "Failed to enable supplies: %d\n",
                                         ret);
                                 return ret;
                         }
 
                         wm8962_sync_cache(codec);
@@ skipping 29 matching lines @@
                                     WM8962_VMID_SEL_MASK | WM8962_BIAS_ENA, 0);
 
                 snd_soc_update_bits(codec, WM8962_ANTI_POP,
                                     WM8962_STARTUP_BIAS_ENA |
                                     WM8962_VMID_BUF_ENA, 0);
 
                 regulator_bulk_disable(ARRAY_SIZE(wm8962->supplies),
                                        wm8962->supplies);
                 break;
         }
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
         return 0;
 }
 
 static const struct {
         int rate;
         int reg;
 } sr_vals[] = {
         { 48000, 0 },
         { 44100, 0 },
         { 32000, 1 },
@@ skipping 449 matching lines @@
 
         if (active & WM8962_FIFOS_ERR_EINT)
                 dev_err(codec->dev, "FIFO error\n");
 
         if (active & WM8962_TEMP_SHUT_EINT)
                 dev_crit(codec->dev, "Thermal shutdown\n");
 
         if (active & (WM8962_MICSCD_EINT | WM8962_MICD_EINT)) {
                 dev_dbg(codec->dev, "Microphone event detected\n");
 
+#ifndef CONFIG_SND_SOC_WM8962_MODULE
+                trace_snd_soc_jack_irq(dev_name(codec->dev));
+#endif
+
+                pm_wakeup_event(codec->dev, 300);
+
                 schedule_delayed_work(&wm8962->mic_work,
                                       msecs_to_jiffies(250));
         }
 
         /* Acknowledge the interrupts */
         snd_soc_write(codec, WM8962_INTERRUPT_STATUS_2, active);
 
         return IRQ_HANDLED;
 }
 
@@ skipping 65 matching lines @@
 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 static int beep_rates[] = {
         500, 1000, 2000, 4000,
 };
 
 static void wm8962_beep_work(struct work_struct *work)
 {
         struct wm8962_priv *wm8962 =
                 container_of(work, struct wm8962_priv, beep_work);
         struct snd_soc_codec *codec = wm8962->codec;
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
         int i;
         int reg = 0;
         int best = 0;
 
         if (wm8962->beep_rate) {
                 for (i = 0; i < ARRAY_SIZE(beep_rates); i++) {
                         if (abs(wm8962->beep_rate - beep_rates[i]) <
                             abs(wm8962->beep_rate - beep_rates[best]))
                                 best = i;
                 }
 
                 dev_dbg(codec->dev, "Set beep rate %dHz for requested %dHz\n",
                         beep_rates[best], wm8962->beep_rate);
 
                 reg = WM8962_BEEP_ENA | (best << WM8962_BEEP_RATE_SHIFT);
 
-                snd_soc_dapm_enable_pin(codec, "Beep");
+                snd_soc_dapm_enable_pin(dapm, "Beep");
         } else {
                 dev_dbg(codec->dev, "Disabling beep\n");
-                snd_soc_dapm_disable_pin(codec, "Beep");
+                snd_soc_dapm_disable_pin(dapm, "Beep");
         }
 
         snd_soc_update_bits(codec, WM8962_BEEP_GENERATOR_1,
                             WM8962_BEEP_ENA | WM8962_BEEP_RATE_MASK, reg);
 
-        snd_soc_dapm_sync(codec);
+        snd_soc_dapm_sync(dapm);
 }
 
 /* For usability define a way of injecting beep events for the device -
  * many systems will not have a keyboard.
  */
 static int wm8962_beep_event(struct input_dev *dev, unsigned int type,
                              unsigned int code, int hz)
 {
         struct snd_soc_codec *codec = input_get_drvdata(dev);
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
@@ skipping 148 matching lines @@
 
         return 0;
 }
 
 static void wm8962_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
         struct wm8962_priv *wm8962 = gpio_to_wm8962(chip);
         struct snd_soc_codec *codec = wm8962->codec;
 
         snd_soc_update_bits(codec, WM8962_GPIO_BASE + offset,
-                            WM8962_GP2_LVL, value << WM8962_GP2_LVL_SHIFT);
+                            WM8962_GP2_LVL, !!value << WM8962_GP2_LVL_SHIFT);
 }
 
 static int wm8962_gpio_direction_out(struct gpio_chip *chip,
                                      unsigned offset, int value)
 {
         struct wm8962_priv *wm8962 = gpio_to_wm8962(chip);
         struct snd_soc_codec *codec = wm8962->codec;
         int val;
 
         /* Force function 1 (logic output) */
@@ skipping 58 matching lines @@
         struct wm8962_pdata *pdata = dev_get_platdata(codec->dev);
         struct i2c_client *i2c = container_of(codec->dev, struct i2c_client,
                                               dev);
         u16 *reg_cache = codec->reg_cache;
         int i, trigger, irq_pol;
 
         wm8962->codec = codec;
         INIT_DELAYED_WORK(&wm8962->mic_work, wm8962_mic_work);
 
         codec->cache_sync = 1;
-        codec->idle_bias_off = 1;
+        codec->dapm.idle_bias_off = 1;
 
         ret = snd_soc_codec_set_cache_io(codec, 16, 16, SND_SOC_I2C);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 goto err;
         }
 
         for (i = 0; i < ARRAY_SIZE(wm8962->supplies); i++)
                 wm8962->supplies[i].supply = wm8962_supply_names[i];
 
@@ skipping 87 matching lines @@
                 if (pdata->mic_cfg)
                         snd_soc_update_bits(codec, WM8962_ADDITIONAL_CONTROL_4,
                                             WM8962_MICDET_ENA |
                                             WM8962_MICDET_THR_MASK |
                                             WM8962_MICSHORT_THR_MASK |
                                             WM8962_MICBIAS_LVL,
                                             pdata->mic_cfg);
         }
 
         /* Latch volume update bits */
-        reg_cache[WM8962_LEFT_INPUT_VOLUME] |= WM8962_IN_VU;
-        reg_cache[WM8962_RIGHT_INPUT_VOLUME] |= WM8962_IN_VU;
-        reg_cache[WM8962_LEFT_ADC_VOLUME] |= WM8962_ADC_VU;
-        reg_cache[WM8962_RIGHT_ADC_VOLUME] |= WM8962_ADC_VU;
-        reg_cache[WM8962_LEFT_DAC_VOLUME] |= WM8962_DAC_VU;
-        reg_cache[WM8962_RIGHT_DAC_VOLUME] |= WM8962_DAC_VU;
-        reg_cache[WM8962_SPKOUTL_VOLUME] |= WM8962_SPKOUT_VU;
-        reg_cache[WM8962_SPKOUTR_VOLUME] |= WM8962_SPKOUT_VU;
-        reg_cache[WM8962_HPOUTL_VOLUME] |= WM8962_HPOUT_VU;
-        reg_cache[WM8962_HPOUTR_VOLUME] |= WM8962_HPOUT_VU;
+        snd_soc_update_bits(codec, WM8962_LEFT_INPUT_VOLUME,
+                            WM8962_IN_VU, WM8962_IN_VU);
+        snd_soc_update_bits(codec, WM8962_RIGHT_INPUT_VOLUME,
+                            WM8962_IN_VU, WM8962_IN_VU);
+        snd_soc_update_bits(codec, WM8962_LEFT_ADC_VOLUME,
+                            WM8962_ADC_VU, WM8962_ADC_VU);
+        snd_soc_update_bits(codec, WM8962_RIGHT_ADC_VOLUME,
+                            WM8962_ADC_VU, WM8962_ADC_VU);
+        snd_soc_update_bits(codec, WM8962_LEFT_DAC_VOLUME,
+                            WM8962_DAC_VU, WM8962_DAC_VU);
+        snd_soc_update_bits(codec, WM8962_RIGHT_DAC_VOLUME,
+                            WM8962_DAC_VU, WM8962_DAC_VU);
+        snd_soc_update_bits(codec, WM8962_SPKOUTL_VOLUME,
+                            WM8962_SPKOUT_VU, WM8962_SPKOUT_VU);
+        snd_soc_update_bits(codec, WM8962_SPKOUTR_VOLUME,
+                            WM8962_SPKOUT_VU, WM8962_SPKOUT_VU);
+        snd_soc_update_bits(codec, WM8962_HPOUTL_VOLUME,
+                            WM8962_HPOUT_VU, WM8962_HPOUT_VU);
+        snd_soc_update_bits(codec, WM8962_HPOUTR_VOLUME,
+                            WM8962_HPOUT_VU, WM8962_HPOUT_VU);
 
         wm8962_add_widgets(codec);
 
         wm8962_init_beep(codec);
         wm8962_init_gpio(codec);
 
         if (i2c->irq) {
                 if (pdata && pdata->irq_active_low) {
                         trigger = IRQF_TRIGGER_LOW;
                         irq_pol = WM8962_IRQ_POL;
@@ skipping 21 matching lines @@
                 }
         }
 
         return 0;
 
 err_enable:
         regulator_bulk_disable(ARRAY_SIZE(wm8962->supplies), wm8962->supplies);
 err_get:
         regulator_bulk_free(ARRAY_SIZE(wm8962->supplies), wm8962->supplies);
 err:
-        kfree(wm8962);
         return ret;
 }
 
 static int wm8962_remove(struct snd_soc_codec *codec)
 {
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
         struct i2c_client *i2c = container_of(codec->dev, struct i2c_client,
                                               dev);
         int i;
 
@@ skipping 87 matching lines @@
 {
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         i2c_del_driver(&wm8962_i2c_driver);
 #endif
 }
 module_exit(wm8962_exit);
 
 MODULE_DESCRIPTION("ASoC WM8962 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_LICENSE("GPL");