CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/twl4030.c

 /*
  * ALSA SoC TWL4030 codec driver
  *
  * Author:      Steve Sakoman, <steve@sakoman.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.
  *
  * This program is distributed in the hope that it will be useful, but
@@ skipping 14 matching lines @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/i2c/twl.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>
 
 /* Register descriptions are here */
 #include <linux/mfd/twl4030-codec.h>
 
 /* Shadow register used by the audio driver */
 #define TWL4030_REG_SW_SHADOW           0x4A
 #define TWL4030_CACHEREGNUM     (TWL4030_REG_SW_SHADOW + 1)
 
@@ skipping 180 matching lines @@
                         write_to_reg = 1;
                         break;
                 }
                 if (write_to_reg)
                         return twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
                                                     value, reg);
         }
         return 0;
 }
 
+static inline void twl4030_wait_ms(int time)
+{
+        if (time < 60) {
+                time *= 1000;
+                usleep_range(time, time + 500);
+        } else {
+                msleep(time);
+        }
+}
+
 static void twl4030_codec_enable(struct snd_soc_codec *codec, int enable)
 {
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         int mode;
 
         if (enable == twl4030->codec_powered)
                 return;
 
         if (enable)
                 mode = twl4030_codec_enable_resource(TWL4030_CODEC_RES_POWER);
@@ skipping 85 matching lines @@
 
         /* initiate offset cancellation */
         twl4030_codec_enable(codec, 1);
 
         reg = twl4030_read_reg_cache(codec, TWL4030_REG_ANAMICL);
         reg &= ~TWL4030_OFFSET_CNCL_SEL;
         reg |= pdata->offset_cncl_path;
         twl4030_write(codec, TWL4030_REG_ANAMICL,
                 reg | TWL4030_CNCL_OFFSET_START);
 
-        /* wait for offset cancellation to complete */
+        /*
+         * Wait for offset cancellation to complete.
+         * Since this takes a while, do not slam the i2c.
+         * Start polling the status after ~20ms.
+         */
+        msleep(20);
         do {
-                /* this takes a little while, so don't slam i2c */
-                udelay(2000);
+                usleep_range(1000, 2000);
                 twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte,
                                     TWL4030_REG_ANAMICL);
         } while ((i++ < 100) &&
                  ((byte & TWL4030_CNCL_OFFSET_START) ==
                   TWL4030_CNCL_OFFSET_START));
 
         /* Make sure that the reg_cache has the same value as the HW */
         twl4030_write_reg_cache(codec, TWL4030_REG_ANAMICL, byte);
 
         twl4030_codec_enable(codec, 0);
@@ skipping 363 matching lines @@
 }
 
 static void headset_ramp(struct snd_soc_codec *codec, int ramp)
 {
         struct twl4030_codec_audio_data *pdata = codec->dev->platform_data;
         unsigned char hs_gain, hs_pop;
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         /* Base values for ramp delay calculation: 2^19 - 2^26 */
         unsigned int ramp_base[] = {524288, 1048576, 2097152, 4194304,
                                     8388608, 16777216, 33554432, 67108864};
+        unsigned int delay;
 
         hs_gain = twl4030_read_reg_cache(codec, TWL4030_REG_HS_GAIN_SET);
         hs_pop = twl4030_read_reg_cache(codec, TWL4030_REG_HS_POPN_SET);
+        delay = (ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] /
+                twl4030->sysclk) + 1;
 
         /* Enable external mute control, this dramatically reduces
          * the pop-noise */
         if (pdata && pdata->hs_extmute) {
                 if (pdata->set_hs_extmute) {
                         pdata->set_hs_extmute(1);
                 } else {
                         hs_pop |= TWL4030_EXTMUTE;
                         twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
                 }
         }
 
         if (ramp) {
                 /* Headset ramp-up according to the TRM */
                 hs_pop |= TWL4030_VMID_EN;
                 twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
                 /* Actually write to the register */
                 twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
                                         hs_gain,
                                         TWL4030_REG_HS_GAIN_SET);
                 hs_pop |= TWL4030_RAMP_EN;
                 twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
                 /* Wait ramp delay time + 1, so the VMID can settle */
-                mdelay((ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] /
-                        twl4030->sysclk) + 1);
+                twl4030_wait_ms(delay);
         } else {
                 /* Headset ramp-down _not_ according to
                  * the TRM, but in a way that it is working */
                 hs_pop &= ~TWL4030_RAMP_EN;
                 twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
                 /* Wait ramp delay time + 1, so the VMID can settle */
-                mdelay((ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] /
-                        twl4030->sysclk) + 1);
+                twl4030_wait_ms(delay);
                 /* Bypass the reg_cache to mute the headset */
                 twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
                                         hs_gain & (~0x0f),
                                         TWL4030_REG_HS_GAIN_SET);
 
                 hs_pop &= ~TWL4030_VMID_EN;
                 twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
         }
 
         /* Disable external mute */
@@ skipping 54 matching lines @@
         }
         return 0;
 }
 
 static int digimic_event(struct snd_soc_dapm_widget *w,
                 struct snd_kcontrol *kcontrol, int event)
 {
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(w->codec);
 
         if (twl4030->digimic_delay)
-                mdelay(twl4030->digimic_delay);
+                twl4030_wait_ms(twl4030->digimic_delay);
         return 0;
 }
 
 /*
  * Some of the gain controls in TWL (mostly those which are associated with
  * the outputs) are implemented in an interesting way:
  * 0x0 : Power down (mute)
  * 0x1 : 6dB
  * 0x2 : 0 dB
  * 0x3 : -6 dB
@@ skipping 765 matching lines @@
         {"Voice Digital Loopback", "Volume", "TX2 Capture Route"},
 
         {"Digital R2 Playback Mixer", NULL, "Right Digital Loopback"},
         {"Digital L2 Playback Mixer", NULL, "Left Digital Loopback"},
         {"Digital Voice Playback Mixer", NULL, "Voice Digital Loopback"},
 
 };
 
 static int twl4030_add_widgets(struct snd_soc_codec *codec)
 {
-        snd_soc_dapm_new_controls(codec, twl4030_dapm_widgets,
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+
+        snd_soc_dapm_new_controls(dapm, twl4030_dapm_widgets,
                                  ARRAY_SIZE(twl4030_dapm_widgets));
-
-        snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
+        snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon));
 
         return 0;
 }
 
 static int twl4030_set_bias_level(struct snd_soc_codec *codec,
                                   enum snd_soc_bias_level level)
 {
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
         case SND_SOC_BIAS_PREPARE:
                 break;
         case SND_SOC_BIAS_STANDBY:
-                if (codec->bias_level == SND_SOC_BIAS_OFF)
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
                         twl4030_codec_enable(codec, 1);
                 break;
         case SND_SOC_BIAS_OFF:
                 twl4030_codec_enable(codec, 0);
                 break;
         }
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
 
         return 0;
 }
 
 static void twl4030_constraints(struct twl4030_priv *twl4030,
                                 struct snd_pcm_substream *mst_substream)
 {
         struct snd_pcm_substream *slv_substream;
 
         /* Pick the stream, which need to be constrained */
@@ skipping 43 matching lines @@
         twl4030_write(codec, TWL4030_REG_OPTION, reg);
 }
 
 static int twl4030_startup(struct snd_pcm_substream *substream,
                            struct snd_soc_dai *dai)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_codec *codec = rtd->codec;
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
 
+        snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24);
         if (twl4030->master_substream) {
                 twl4030->slave_substream = substream;
                 /* The DAI has one configuration for playback and capture, so
                  * if the DAI has been already configured then constrain this
                  * substream to match it. */
                 if (twl4030->configured)
                         twl4030_constraints(twl4030, twl4030->master_substream);
         } else {
                 if (!(twl4030_read_reg_cache(codec, TWL4030_REG_CODEC_MODE) &
                         TWL4030_OPTION_1)) {
@@ skipping 104 matching lines @@
         }
 
         /* sample size */
         old_format = twl4030_read_reg_cache(codec, TWL4030_REG_AUDIO_IF);
         format = old_format;
         format &= ~TWL4030_DATA_WIDTH;
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
                 format |= TWL4030_DATA_WIDTH_16S_16W;
                 break;
-        case SNDRV_PCM_FORMAT_S24_LE:
+        case SNDRV_PCM_FORMAT_S32_LE:
                 format |= TWL4030_DATA_WIDTH_32S_24W;
                 break;
         default:
                 printk(KERN_ERR "TWL4030 hw params: unknown format %d\n",
                         params_format(params));
                 return -EINVAL;
         }
 
         if (format != old_format || mode != old_mode) {
                 if (twl4030->codec_powered) {
@@ skipping 312 matching lines @@
 
         if (tristate)
                 reg |= TWL4030_VIF_TRI_EN;
         else
                 reg &= ~TWL4030_VIF_TRI_EN;
 
         return twl4030_write(codec, TWL4030_REG_VOICE_IF, reg);
 }
 
 #define TWL4030_RATES    (SNDRV_PCM_RATE_8000_48000)
-#define TWL4030_FORMATS  (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FORMAT_S24_LE)
+#define TWL4030_FORMATS  (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
 
 static struct snd_soc_dai_ops twl4030_dai_hifi_ops = {
         .startup        = twl4030_startup,
         .shutdown       = twl4030_shutdown,
         .hw_params      = twl4030_hw_params,
         .set_sysclk     = twl4030_set_dai_sysclk,
         .set_fmt        = twl4030_set_dai_fmt,
         .set_tristate   = twl4030_set_tristate,
 };
 
@@ skipping 58 matching lines @@
         struct twl4030_priv *twl4030;
 
         twl4030 = kzalloc(sizeof(struct twl4030_priv), GFP_KERNEL);
         if (twl4030 == NULL) {
                 printk("Can not allocate memroy\n");
                 return -ENOMEM;
         }
         snd_soc_codec_set_drvdata(codec, twl4030);
         /* Set the defaults, and power up the codec */
         twl4030->sysclk = twl4030_codec_get_mclk() / 1000;
-        codec->idle_bias_off = 1;
+        codec->dapm.idle_bias_off = 1;
 
         twl4030_init_chip(codec);
 
         snd_soc_add_controls(codec, twl4030_snd_controls,
                                 ARRAY_SIZE(twl4030_snd_controls));
         twl4030_add_widgets(codec);
         return 0;
 }
 
 static int twl4030_soc_remove(struct snd_soc_codec *codec)
 {
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
+
         /* Reset registers to their chip default before leaving */
         twl4030_reset_registers(codec);
         twl4030_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        kfree(twl4030);
         return 0;
 }
 
 static struct snd_soc_codec_driver soc_codec_dev_twl4030 = {
         .probe = twl4030_soc_probe,
         .remove = twl4030_soc_remove,
         .suspend = twl4030_soc_suspend,
         .resume = twl4030_soc_resume,
         .read = twl4030_read_reg_cache,
         .write = twl4030_write,
@@ skipping 11 matching lines @@
                 dev_err(&pdev->dev, "platform_data is missing\n");
                 return -EINVAL;
         }
 
         return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_twl4030,
                         twl4030_dai, ARRAY_SIZE(twl4030_dai));
 }
 
 static int __devexit twl4030_codec_remove(struct platform_device *pdev)
 {
-        struct twl4030_priv *twl4030 = dev_get_drvdata(&pdev->dev);
-
         snd_soc_unregister_codec(&pdev->dev);
-        kfree(twl4030);
         return 0;
 }
 
 MODULE_ALIAS("platform:twl4030-codec");
 
 static struct platform_driver twl4030_codec_driver = {
         .probe          = twl4030_codec_probe,
         .remove         = __devexit_p(twl4030_codec_remove),
         .driver         = {
                 .name   = "twl4030-codec",
                 .owner  = THIS_MODULE,
         },
 };
 
 static int __init twl4030_modinit(void)
 {
         return platform_driver_register(&twl4030_codec_driver);
 }
 module_init(twl4030_modinit);
 
 static void __exit twl4030_exit(void)
 {
         platform_driver_unregister(&twl4030_codec_driver);
 }
 module_exit(twl4030_exit);
 
 MODULE_DESCRIPTION("ASoC TWL4030 codec driver");
 MODULE_AUTHOR("Steve Sakoman");
 MODULE_LICENSE("GPL");