CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/wm8350.c

 /*
  * wm8350.c -- WM8350 ALSA SoC audio driver
  *
  * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
  *
  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
  *
  * 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.
  */
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/mfd/wm8350/audio.h>
 #include <linux/mfd/wm8350/core.h>
 #include <linux/regulator/consumer.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 <trace/events/asoc.h>
 
 #include "wm8350.h"
 
 #define WM8350_OUTn_0dB 0x39
 
 #define WM8350_RAMP_NONE        0
 #define WM8350_RAMP_UP          1
 #define WM8350_RAMP_DOWN        2
 
 /* We only include the analogue supplies here; the digital supplies
  * need to be available well before this driver can be probed.
  */
 static const char *supply_names[] = {
         "AVDD",
         "HPVDD",
 };
 
 struct wm8350_output {
         u16 active;
         u16 left_vol;
         u16 right_vol;
         u16 ramp;
         u16 mute;
 };
 
 struct wm8350_jack_data {
         struct snd_soc_jack *jack;
+        struct delayed_work work;
         int report;
         int short_report;
 };
 
 struct wm8350_data {
         struct snd_soc_codec codec;
         struct wm8350_output out1;
         struct wm8350_output out2;
         struct wm8350_jack_data hpl;
         struct wm8350_jack_data hpr;
@@ skipping 156 matching lines @@
 }
 
 /*
  * This work ramps both output PGAs at stream start/stop time to
  * minimise pop associated with DAPM power switching.
  * It's best to enable Zero Cross when ramping occurs to minimise any
  * zipper noises.
  */
 static void wm8350_pga_work(struct work_struct *work)
 {
-        struct snd_soc_codec *codec =
-            container_of(work, struct snd_soc_codec, delayed_work.work);
+        struct snd_soc_dapm_context *dapm =
+            container_of(work, struct snd_soc_dapm_context, delayed_work.work);
+        struct snd_soc_codec *codec = dapm->codec;
         struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
         struct wm8350_output *out1 = &wm8350_data->out1,
             *out2 = &wm8350_data->out2;
         int i, out1_complete, out2_complete;
 
         /* do we need to ramp at all ? */
         if (out1->ramp == WM8350_RAMP_NONE && out2->ramp == WM8350_RAMP_NONE)
                 return;
 
         /* PGA volumes have 6 bits of resolution to ramp */
@@ skipping 50 matching lines @@
         default:
                 BUG();
                 return -1;
         }
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
                 out->ramp = WM8350_RAMP_UP;
                 out->active = 1;
 
-                if (!delayed_work_pending(&codec->delayed_work))
-                        schedule_delayed_work(&codec->delayed_work,
+                if (!delayed_work_pending(&codec->dapm.delayed_work))
+                        schedule_delayed_work(&codec->dapm.delayed_work,
                                               msecs_to_jiffies(1));
                 break;
 
         case SND_SOC_DAPM_PRE_PMD:
                 out->ramp = WM8350_RAMP_DOWN;
                 out->active = 0;
 
-                if (!delayed_work_pending(&codec->delayed_work))
-                        schedule_delayed_work(&codec->delayed_work,
+                if (!delayed_work_pending(&codec->dapm.delayed_work))
+                        schedule_delayed_work(&codec->dapm.delayed_work,
                                               msecs_to_jiffies(1));
                 break;
         }
 
         return 0;
 }
 
 static int wm8350_put_volsw_2r_vu(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_value *ucontrol)
 {
@@ skipping 453 matching lines @@
 
         /* out 4 capture */
         {"Out4 Capture Channel", NULL, "Out4 Mixer"},
 
         /* Beep */
         {"Beep", NULL, "IN3R PGA"},
 };
 
 static int wm8350_add_widgets(struct snd_soc_codec *codec)
 {
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
         int ret;
 
-        ret = snd_soc_dapm_new_controls(codec,
+        ret = snd_soc_dapm_new_controls(dapm,
                                         wm8350_dapm_widgets,
                                         ARRAY_SIZE(wm8350_dapm_widgets));
         if (ret != 0) {
                 dev_err(codec->dev, "dapm control register failed\n");
                 return ret;
         }
 
         /* set up audio paths */
-        ret = snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+        ret = snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
         if (ret != 0) {
                 dev_err(codec->dev, "DAPM route register failed\n");
                 return ret;
         }
 
         return 0;
 }
 
 static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai,
                                  int clk_id, unsigned int freq, int dir)
@@ skipping 366 matching lines @@
                 break;
 
         case SND_SOC_BIAS_PREPARE:
                 pm1 = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_1);
                 pm1 &= ~WM8350_VMID_MASK;
                 wm8350_reg_write(wm8350, WM8350_POWER_MGMT_1,
                                  pm1 | WM8350_VMID_50K);
                 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(priv->supplies),
                                                     priv->supplies);
                         if (ret != 0)
                                 return ret;
 
                         /* Enable the system clock */
                         wm8350_set_bits(wm8350, WM8350_POWER_MGMT_4,
                                         WM8350_SYSCLK_ENA);
 
                         /* mute DAC & outputs */
@@ skipping 112 matching lines @@
                                   WM8350_OUT2R_ENA);
 
                 /* disable clock gen */
                 wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_4,
                                   WM8350_SYSCLK_ENA);
 
                 regulator_bulk_disable(ARRAY_SIZE(priv->supplies),
                                        priv->supplies);
                 break;
         }
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
         return 0;
 }
 
 static int wm8350_suspend(struct snd_soc_codec *codec, pm_message_t state)
 {
         wm8350_set_bias_level(codec, SND_SOC_BIAS_OFF);
         return 0;
 }
 
 static int wm8350_resume(struct snd_soc_codec *codec)
 {
         wm8350_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         return 0;
 }
 
-static irqreturn_t wm8350_hp_jack_handler(int irq, void *data)
+static void wm8350_hp_work(struct wm8350_data *priv,
+                           struct wm8350_jack_data *jack,
+                           u16 mask)
 {
-        struct wm8350_data *priv = data;
         struct wm8350 *wm8350 = priv->codec.control_data;
         u16 reg;
         int report;
-        int mask;
-        struct wm8350_jack_data *jack = NULL;
-
-        switch (irq - wm8350->irq_base) {
-        case WM8350_IRQ_CODEC_JCK_DET_L:
-                jack = &priv->hpl;
-                mask = WM8350_JACK_L_LVL;
-                break;
-
-        case WM8350_IRQ_CODEC_JCK_DET_R:
-                jack = &priv->hpr;
-                mask = WM8350_JACK_R_LVL;
-                break;
-
-        default:
-                BUG();
-        }
-
-        if (!jack->jack) {
-                dev_warn(wm8350->dev, "Jack interrupt called with no jack\n");
-                return IRQ_NONE;
-        }
-
-        /* Debounce */
-        msleep(200);
 
         reg = wm8350_reg_read(wm8350, WM8350_JACK_PIN_STATUS);
         if (reg & mask)
                 report = jack->report;
         else
                 report = 0;
 
         snd_soc_jack_report(jack->jack, report, jack->report);
 
+}
+
+static void wm8350_hpl_work(struct work_struct *work)
+{
+        struct wm8350_data *priv =
+            container_of(work, struct wm8350_data, hpl.work.work);
+
+        wm8350_hp_work(priv, &priv->hpl, WM8350_JACK_L_LVL);
+}
+
+static void wm8350_hpr_work(struct work_struct *work)
+{
+        struct wm8350_data *priv =
+            container_of(work, struct wm8350_data, hpr.work.work);
+        
+        wm8350_hp_work(priv, &priv->hpr, WM8350_JACK_R_LVL);
+}
+
+static irqreturn_t wm8350_hp_jack_handler(int irq, void *data)
+{
+        struct wm8350_data *priv = data;
+        struct wm8350 *wm8350 = priv->codec.control_data;
+        struct wm8350_jack_data *jack = NULL;
+
+        switch (irq - wm8350->irq_base) {
+        case WM8350_IRQ_CODEC_JCK_DET_L:
+#ifndef CONFIG_SND_SOC_WM8350_MODULE
+                trace_snd_soc_jack_irq("WM8350 HPL");
+#endif
+                jack = &priv->hpl;
+                break;
+
+        case WM8350_IRQ_CODEC_JCK_DET_R:
+#ifndef CONFIG_SND_SOC_WM8350_MODULE
+                trace_snd_soc_jack_irq("WM8350 HPR");
+#endif
+                jack = &priv->hpr;
+                break;
+
+        default:
+                BUG();
+        }
+
+        if (device_may_wakeup(wm8350->dev))
+                pm_wakeup_event(wm8350->dev, 250);
+
+        schedule_delayed_work(&jack->work, 200);
+
         return IRQ_HANDLED;
 }
 
 /**
  * wm8350_hp_jack_detect - Enable headphone jack detection.
  *
  * @codec:  WM8350 codec
  * @which:  left or right jack detect signal
  * @jack:   jack to report detection events on
  * @report: value to report
@@ skipping 42 matching lines @@
 }
 EXPORT_SYMBOL_GPL(wm8350_hp_jack_detect);
 
 static irqreturn_t wm8350_mic_handler(int irq, void *data)
 {
         struct wm8350_data *priv = data;
         struct wm8350 *wm8350 = priv->codec.control_data;
         u16 reg;
         int report = 0;
 
+#ifndef CONFIG_SND_SOC_WM8350_MODULE
+        trace_snd_soc_jack_irq("WM8350 mic");
+#endif
+
         reg = wm8350_reg_read(wm8350, WM8350_JACK_PIN_STATUS);
         if (reg & WM8350_JACK_MICSCD_LVL)
                 report |= priv->mic.short_report;
         if (reg & WM8350_JACK_MICSD_LVL)
                 report |= priv->mic.report;
 
         snd_soc_jack_report(priv->mic.jack, report,
                             priv->mic.report | priv->mic.short_report);
 
         return IRQ_HANDLED;
@@ skipping 94 matching lines @@
                                  priv->supplies);
         if (ret != 0)
                 goto err_priv;
 
         wm8350->codec.codec = codec;
         codec->control_data = wm8350;
 
         /* Put the codec into reset if it wasn't already */
         wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);
 
-        INIT_DELAYED_WORK(&codec->delayed_work, wm8350_pga_work);
+        INIT_DELAYED_WORK(&codec->dapm.delayed_work, wm8350_pga_work);
+        INIT_DELAYED_WORK(&priv->hpl.work, wm8350_hpl_work);
+        INIT_DELAYED_WORK(&priv->hpr.work, wm8350_hpr_work);
 
         /* Enable the codec */
         wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);
 
         /* Enable robust clocking mode in ADC */
         wm8350_codec_write(codec, WM8350_SECURITY, 0xa7);
         wm8350_codec_write(codec, 0xde, 0x13);
         wm8350_codec_write(codec, WM8350_SECURITY, 0);
 
         /* read OUT1 & OUT2 volumes */
@@ skipping 55 matching lines @@
 
 err_priv:
         kfree(priv);
         return ret;
 }
 
 static int  wm8350_codec_remove(struct snd_soc_codec *codec)
 {
         struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec);
         struct wm8350 *wm8350 = dev_get_platdata(codec->dev);
-        int ret;
 
         wm8350_clear_bits(wm8350, WM8350_JACK_DETECT,
                           WM8350_JDL_ENA | WM8350_JDR_ENA);
         wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_4, WM8350_TOCLK_ENA);
 
         wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_MICD, priv);
         wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_MICSCD, priv);
         wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L, priv);
         wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R, priv);
 
         priv->hpl.jack = NULL;
         priv->hpr.jack = NULL;
         priv->mic.jack = NULL;
 
-        /* cancel any work waiting to be queued. */
-        ret = cancel_delayed_work(&codec->delayed_work);
+        cancel_delayed_work_sync(&priv->hpl.work);
+        cancel_delayed_work_sync(&priv->hpr.work);
 
         /* if there was any work waiting then we run it now and
          * wait for its completion */
-        if (ret) {
-                schedule_delayed_work(&codec->delayed_work, 0);
-                flush_scheduled_work();
-        }
+        flush_delayed_work_sync(&codec->dapm.delayed_work);
 
         wm8350_set_bias_level(codec, SND_SOC_BIAS_OFF);
 
         wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);
 
         regulator_bulk_free(ARRAY_SIZE(priv->supplies), priv->supplies);
         kfree(priv);
         return 0;
 }
 
@@ skipping 37 matching lines @@
 static __exit void wm8350_exit(void)
 {
         platform_driver_unregister(&wm8350_codec_driver);
 }
 module_exit(wm8350_exit);
 
 MODULE_DESCRIPTION("ASoC WM8350 driver");
 MODULE_AUTHOR("Liam Girdwood");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:wm8350-codec");