1 files changed, 733 insertions, 109 deletions

diff --git a/sound/soc/codecs/twl6040.c b/sound/soc/codecs/twl6040.c
index b92f2b737e4c..2f68f5949a63 100644
--- a/sound/soc/codecs/twl6040.c
+++ b/sound/soc/codecs/twl6040.c
@@ -39,8 +39,41 @@
 
 #include "twl6040.h"
 
-#define TWL6040_RATES    (SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
-#define TWL6040_FORMATS  (SNDRV_PCM_FMTBIT_S32_LE)
+#define TWL6040_RATES           SNDRV_PCM_RATE_8000_96000
+#define TWL6040_FORMATS (SNDRV_PCM_FMTBIT_S32_LE)
+
+#define TWL6040_OUTHS_0dB 0x00
+#define TWL6040_OUTHS_M30dB 0x0F
+#define TWL6040_OUTHF_0dB 0x03
+#define TWL6040_OUTHF_M52dB 0x1D
+
+#define TWL6040_RAMP_NONE       0
+#define TWL6040_RAMP_UP         1
+#define TWL6040_RAMP_DOWN       2
+
+#define TWL6040_HSL_VOL_MASK    0x0F
+#define TWL6040_HSL_VOL_SHIFT   0
+#define TWL6040_HSR_VOL_MASK    0xF0
+#define TWL6040_HSR_VOL_SHIFT   4
+#define TWL6040_HF_VOL_MASK     0x1F
+#define TWL6040_HF_VOL_SHIFT    0
+
+struct twl6040_output {
+        u16 active;
+        u16 left_vol;
+        u16 right_vol;
+        u16 left_step;
+        u16 right_step;
+        unsigned int step_delay;
+        u16 ramp;
+        u16 mute;
+        struct completion ramp_done;
+};
+
+struct twl6040_jack_data {
+        struct snd_soc_jack *jack;
+        int report;
+};
 
 /* codec private data */
 struct twl6040_data {
@@ -52,6 +85,17 @@ struct twl6040_data {
         unsigned int sysclk;
         struct snd_pcm_hw_constraint_list *sysclk_constraints;
         struct completion ready;
+        struct twl6040_jack_data hs_jack;
+        struct snd_soc_codec *codec;
+        struct workqueue_struct *workqueue;
+        struct delayed_work delayed_work;
+        struct mutex mutex;
+        struct twl6040_output headset;
+        struct twl6040_output handsfree;
+        struct workqueue_struct *hf_workqueue;
+        struct workqueue_struct *hs_workqueue;
+        struct delayed_work hs_delayed_work;
+        struct delayed_work hf_delayed_work;
 };
 
 /*
@@ -200,7 +244,7 @@ static int twl6040_read_reg_volatile(struct snd_soc_codec *codec,
         if (reg >= TWL6040_CACHEREGNUM)
                 return -EIO;
 
-        twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &value, reg);
+        twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &value, reg);
         twl6040_write_reg_cache(codec, reg, value);
 
         return value;
@@ -216,7 +260,7 @@ static int twl6040_write(struct snd_soc_codec *codec,
                 return -EIO;
 
         twl6040_write_reg_cache(codec, reg, value);
-        return twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value, reg);
+        return twl_i2c_write_u8(TWL_MODULE_AUDIO_VOICE, value, reg);
 }
 
 static void twl6040_init_vio_regs(struct snd_soc_codec *codec)
@@ -253,6 +297,305 @@ static void twl6040_init_vdd_regs(struct snd_soc_codec *codec)
         }
 }
 
+/*
+ * Ramp HS PGA volume to minimise pops at stream startup and shutdown.
+ */
+static inline int twl6040_hs_ramp_step(struct snd_soc_codec *codec,
+                        unsigned int left_step, unsigned int right_step)
+{
+
+        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_output *headset = &priv->headset;
+        int left_complete = 0, right_complete = 0;
+        u8 reg, val;
+
+        /* left channel */
+        left_step = (left_step > 0xF) ? 0xF : left_step;
+        reg = twl6040_read_reg_cache(codec, TWL6040_REG_HSGAIN);
+        val = (~reg & TWL6040_HSL_VOL_MASK);
+
+        if (headset->ramp == TWL6040_RAMP_UP) {
+                /* ramp step up */
+                if (val < headset->left_vol) {
+                        val += left_step;
+                        reg &= ~TWL6040_HSL_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HSGAIN,
+                                        (reg | (~val & TWL6040_HSL_VOL_MASK)));
+                } else {
+                        left_complete = 1;
+                }
+        } else if (headset->ramp == TWL6040_RAMP_DOWN) {
+                /* ramp step down */
+                if (val > 0x0) {
+                        val -= left_step;
+                        reg &= ~TWL6040_HSL_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HSGAIN, reg |
+                                                (~val & TWL6040_HSL_VOL_MASK));
+                } else {
+                        left_complete = 1;
+                }
+        }
+
+        /* right channel */
+        right_step = (right_step > 0xF) ? 0xF : right_step;
+        reg = twl6040_read_reg_cache(codec, TWL6040_REG_HSGAIN);
+        val = (~reg & TWL6040_HSR_VOL_MASK) >> TWL6040_HSR_VOL_SHIFT;
+
+        if (headset->ramp == TWL6040_RAMP_UP) {
+                /* ramp step up */
+                if (val < headset->right_vol) {
+                        val += right_step;
+                        reg &= ~TWL6040_HSR_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HSGAIN,
+                                (reg | (~val << TWL6040_HSR_VOL_SHIFT)));
+                } else {
+                        right_complete = 1;
+                }
+        } else if (headset->ramp == TWL6040_RAMP_DOWN) {
+                /* ramp step down */
+                if (val > 0x0) {
+                        val -= right_step;
+                        reg &= ~TWL6040_HSR_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HSGAIN,
+                                         reg | (~val << TWL6040_HSR_VOL_SHIFT));
+                } else {
+                        right_complete = 1;
+                }
+        }
+
+        return left_complete & right_complete;
+}
+
+/*
+ * Ramp HF PGA volume to minimise pops at stream startup and shutdown.
+ */
+static inline int twl6040_hf_ramp_step(struct snd_soc_codec *codec,
+                        unsigned int left_step, unsigned int right_step)
+{
+        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_output *handsfree = &priv->handsfree;
+        int left_complete = 0, right_complete = 0;
+        u16 reg, val;
+
+        /* left channel */
+        left_step = (left_step > 0x1D) ? 0x1D : left_step;
+        reg = twl6040_read_reg_cache(codec, TWL6040_REG_HFLGAIN);
+        reg = 0x1D - reg;
+        val = (reg & TWL6040_HF_VOL_MASK);
+        if (handsfree->ramp == TWL6040_RAMP_UP) {
+                /* ramp step up */
+                if (val < handsfree->left_vol) {
+                        val += left_step;
+                        reg &= ~TWL6040_HF_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HFLGAIN,
+                                                reg | (0x1D - val));
+                } else {
+                        left_complete = 1;
+                }
+        } else if (handsfree->ramp == TWL6040_RAMP_DOWN) {
+                /* ramp step down */
+                if (val > 0) {
+                        val -= left_step;
+                        reg &= ~TWL6040_HF_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HFLGAIN,
+                                                reg | (0x1D - val));
+                } else {
+                        left_complete = 1;
+                }
+        }
+
+        /* right channel */
+        right_step = (right_step > 0x1D) ? 0x1D : right_step;
+        reg = twl6040_read_reg_cache(codec, TWL6040_REG_HFRGAIN);
+        reg = 0x1D - reg;
+        val = (reg & TWL6040_HF_VOL_MASK);
+        if (handsfree->ramp == TWL6040_RAMP_UP) {
+                /* ramp step up */
+                if (val < handsfree->right_vol) {
+                        val += right_step;
+                        reg &= ~TWL6040_HF_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HFRGAIN,
+                                                reg | (0x1D - val));
+                } else {
+                        right_complete = 1;
+                }
+        } else if (handsfree->ramp == TWL6040_RAMP_DOWN) {
+                /* ramp step down */
+                if (val > 0) {
+                        val -= right_step;
+                        reg &= ~TWL6040_HF_VOL_MASK;
+                        twl6040_write(codec, TWL6040_REG_HFRGAIN,
+                                                reg | (0x1D - val));
+                }
+        }
+
+        return left_complete & right_complete;
+}
+
+/*
+ * This work ramps both output PGAs at stream start/stop time to
+ * minimise pop associated with DAPM power switching.
+ */
+static void twl6040_pga_hs_work(struct work_struct *work)
+{
+        struct twl6040_data *priv =
+                container_of(work, struct twl6040_data, hs_delayed_work.work);
+        struct snd_soc_codec *codec = priv->codec;
+        struct twl6040_output *headset = &priv->headset;
+        unsigned int delay = headset->step_delay;
+        int i, headset_complete;
+
+        /* do we need to ramp at all ? */
+        if (headset->ramp == TWL6040_RAMP_NONE)
+                return;
+
+        /* HS PGA volumes have 4 bits of resolution to ramp */
+        for (i = 0; i <= 16; i++) {
+                headset_complete = 1;
+                if (headset->ramp != TWL6040_RAMP_NONE)
+                        headset_complete = twl6040_hs_ramp_step(codec,
+                                                        headset->left_step,
+                                                        headset->right_step);
+
+                /* ramp finished ? */
+                if (headset_complete)
+                        break;
+
+                /*
+                 * TODO: tune: delay is longer over 0dB
+                 * as increases are larger.
+                 */
+                if (i >= 8)
+                        schedule_timeout_interruptible(msecs_to_jiffies(delay +
+                                                        (delay >> 1)));
+                else
+                        schedule_timeout_interruptible(msecs_to_jiffies(delay));
+        }
+
+        if (headset->ramp == TWL6040_RAMP_DOWN) {
+                headset->active = 0;
+                complete(&headset->ramp_done);
+        } else {
+                headset->active = 1;
+        }
+        headset->ramp = TWL6040_RAMP_NONE;
+}
+
+static void twl6040_pga_hf_work(struct work_struct *work)
+{
+        struct twl6040_data *priv =
+                container_of(work, struct twl6040_data, hf_delayed_work.work);
+        struct snd_soc_codec *codec = priv->codec;
+        struct twl6040_output *handsfree = &priv->handsfree;
+        unsigned int delay = handsfree->step_delay;
+        int i, handsfree_complete;
+
+        /* do we need to ramp at all ? */
+        if (handsfree->ramp == TWL6040_RAMP_NONE)
+                return;
+
+        /* HF PGA volumes have 5 bits of resolution to ramp */
+        for (i = 0; i <= 32; i++) {
+                handsfree_complete = 1;
+                if (handsfree->ramp != TWL6040_RAMP_NONE)
+                        handsfree_complete = twl6040_hf_ramp_step(codec,
+                                                        handsfree->left_step,
+                                                        handsfree->right_step);
+
+                /* ramp finished ? */
+                if (handsfree_complete)
+                        break;
+
+                /*
+                 * TODO: tune: delay is longer over 0dB
+                 * as increases are larger.
+                 */
+                if (i >= 16)
+                        schedule_timeout_interruptible(msecs_to_jiffies(delay +
+                                                       (delay >> 1)));
+                else
+                        schedule_timeout_interruptible(msecs_to_jiffies(delay));
+        }
+
+
+        if (handsfree->ramp == TWL6040_RAMP_DOWN) {
+                handsfree->active = 0;
+                complete(&handsfree->ramp_done);
+        } else
+                handsfree->active = 1;
+        handsfree->ramp = TWL6040_RAMP_NONE;
+}
+
+static int pga_event(struct snd_soc_dapm_widget *w,
+                        struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_output *out;
+        struct delayed_work *work;
+        struct workqueue_struct *queue;
+
+        switch (w->shift) {
+        case 2:
+        case 3:
+                out = &priv->headset;
+                work = &priv->hs_delayed_work;
+                queue = priv->hs_workqueue;
+                out->step_delay = 5;    /* 5 ms between volume ramp steps */
+                break;
+        case 4:
+                out = &priv->handsfree;
+                work = &priv->hf_delayed_work;
+                queue = priv->hf_workqueue;
+                out->step_delay = 5;    /* 5 ms between volume ramp steps */
+                if (SND_SOC_DAPM_EVENT_ON(event))
+                        priv->non_lp++;
+                else
+                        priv->non_lp--;
+                break;
+        default:
+                return -1;
+        }
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                if (out->active)
+                        break;
+
+                /* don't use volume ramp for power-up */
+                out->left_step = out->left_vol;
+                out->right_step = out->right_vol;
+
+                if (!delayed_work_pending(work)) {
+                        out->ramp = TWL6040_RAMP_UP;
+                        queue_delayed_work(queue, work,
+                                        msecs_to_jiffies(1));
+                }
+                break;
+
+        case SND_SOC_DAPM_PRE_PMD:
+                if (!out->active)
+                        break;
+
+                if (!delayed_work_pending(work)) {
+                        /* use volume ramp for power-down */
+                        out->left_step = 1;
+                        out->right_step = 1;
+                        out->ramp = TWL6040_RAMP_DOWN;
+                        INIT_COMPLETION(out->ramp_done);
+
+                        queue_delayed_work(queue, work,
+                                        msecs_to_jiffies(1));
+
+                        wait_for_completion_timeout(&out->ramp_done,
+                                        msecs_to_jiffies(2000));
+                }
+                break;
+        }
+
+        return 0;
+}
+
 /* twl6040 codec manual power-up sequence */
 static void twl6040_power_up(struct snd_soc_codec *codec)
 {
@@ -381,6 +724,47 @@ static int twl6040_power_mode_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
+void twl6040_hs_jack_report(struct snd_soc_codec *codec,
+                                struct snd_soc_jack *jack, int report)
+{
+        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
+        int status;
+
+        mutex_lock(&priv->mutex);
+
+        /* Sync status */
+        status = twl6040_read_reg_volatile(codec, TWL6040_REG_STATUS);
+        if (status & TWL6040_PLUGCOMP)
+                snd_soc_jack_report(jack, report, report);
+        else
+                snd_soc_jack_report(jack, 0, report);
+
+        mutex_unlock(&priv->mutex);
+}
+
+void twl6040_hs_jack_detect(struct snd_soc_codec *codec,
+                                struct snd_soc_jack *jack, int report)
+{
+        struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_jack_data *hs_jack = &priv->hs_jack;
+
+        hs_jack->jack = jack;
+        hs_jack->report = report;
+
+        twl6040_hs_jack_report(codec, hs_jack->jack, hs_jack->report);
+}
+EXPORT_SYMBOL_GPL(twl6040_hs_jack_detect);
+
+static void twl6040_accessory_work(struct work_struct *work)
+{
+        struct twl6040_data *priv = container_of(work,
+                                        struct twl6040_data, delayed_work.work);
+        struct snd_soc_codec *codec = priv->codec;
+        struct twl6040_jack_data *hs_jack = &priv->hs_jack;
+
+        twl6040_hs_jack_report(codec, hs_jack->jack, hs_jack->report);
+}
+
 /* audio interrupt handler */
 static irqreturn_t twl6040_naudint_handler(int irq, void *data)
 {
@@ -388,33 +772,180 @@ static irqreturn_t twl6040_naudint_handler(int irq, void *data)
         struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
         u8 intid;
 
-        twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &intid, TWL6040_REG_INTID);
+        twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &intid, TWL6040_REG_INTID);
 
-        switch (intid) {
-        case TWL6040_THINT:
+        if (intid & TWL6040_THINT)
                 dev_alert(codec->dev, "die temp over-limit detection\n");
+
+        if ((intid & TWL6040_PLUGINT) || (intid & TWL6040_UNPLUGINT))
+                queue_delayed_work(priv->workqueue, &priv->delayed_work,
+                                                        msecs_to_jiffies(200));
+
+        if (intid & TWL6040_HOOKINT)
+                dev_info(codec->dev, "hook detection\n");
+
+        if (intid & TWL6040_HFINT)
+                dev_alert(codec->dev, "hf drivers over current detection\n");
+
+        if (intid & TWL6040_VIBINT)
+                dev_alert(codec->dev, "vib drivers over current detection\n");
+
+        if (intid & TWL6040_READYINT)
+                complete(&priv->ready);
+
+        return IRQ_HANDLED;
+}
+
+static int twl6040_put_volsw(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_output *out = NULL;
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        int ret;
+        unsigned int reg = mc->reg;
+
+        /* For HS and HF we shadow the values and only actually write
+         * them out when active in order to ensure the amplifier comes on
+         * as quietly as possible. */
+        switch (reg) {
+        case TWL6040_REG_HSGAIN:
+                out = &twl6040_priv->headset;
                 break;
-        case TWL6040_PLUGINT:
-        case TWL6040_UNPLUGINT:
-        case TWL6040_HOOKINT:
+        default:
                 break;
-        case TWL6040_HFINT:
-                dev_alert(codec->dev, "hf drivers over current detection\n");
+        }
+
+        if (out) {
+                out->left_vol = ucontrol->value.integer.value[0];
+                out->right_vol = ucontrol->value.integer.value[1];
+                if (!out->active)
+                        return 1;
+        }
+
+        ret = snd_soc_put_volsw(kcontrol, ucontrol);
+        if (ret < 0)
+                return ret;
+
+        return 1;
+}
+
+static int twl6040_get_volsw(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_output *out = &twl6040_priv->headset;
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+
+        switch (reg) {
+        case TWL6040_REG_HSGAIN:
+                out = &twl6040_priv->headset;
+                ucontrol->value.integer.value[0] = out->left_vol;
+                ucontrol->value.integer.value[1] = out->right_vol;
+                return 0;
+
+        default:
                 break;
-        case TWL6040_VIBINT:
-                dev_alert(codec->dev, "vib drivers over current detection\n");
+        }
+
+        return snd_soc_get_volsw(kcontrol, ucontrol);
+}
+
+static int twl6040_put_volsw_2r_vu(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_output *out = NULL;
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        int ret;
+        unsigned int reg = mc->reg;
+
+        /* For HS and HF we shadow the values and only actually write
+         * them out when active in order to ensure the amplifier comes on
+         * as quietly as possible. */
+        switch (reg) {
+        case TWL6040_REG_HFLGAIN:
+        case TWL6040_REG_HFRGAIN:
+                out = &twl6040_priv->handsfree;
                 break;
-        case TWL6040_READYINT:
-                complete(&priv->ready);
+        default:
                 break;
+        }
+
+        if (out) {
+                out->left_vol = ucontrol->value.integer.value[0];
+                out->right_vol = ucontrol->value.integer.value[1];
+                if (!out->active)
+                        return 1;
+        }
+
+        ret = snd_soc_put_volsw_2r(kcontrol, ucontrol);
+        if (ret < 0)
+                return ret;
+
+        return 1;
+}
+
+static int twl6040_get_volsw_2r(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec);
+        struct twl6040_output *out = &twl6040_priv->handsfree;
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+
+        /* If these are cached registers use the cache */
+        switch (reg) {
+        case TWL6040_REG_HFLGAIN:
+        case TWL6040_REG_HFRGAIN:
+                out = &twl6040_priv->handsfree;
+                ucontrol->value.integer.value[0] = out->left_vol;
+                ucontrol->value.integer.value[1] = out->right_vol;
+                return 0;
+
         default:
-                dev_err(codec->dev, "unknown audio interrupt %d\n", intid);
                 break;
         }
 
-        return IRQ_HANDLED;
+        return snd_soc_get_volsw_2r(kcontrol, ucontrol);
 }
 
+/* double control with volume update */
+#define SOC_TWL6040_DOUBLE_TLV(xname, xreg, shift_left, shift_right, xmax,\
+                                                        xinvert, tlv_array)\
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw, .get = twl6040_get_volsw, \
+        .put = twl6040_put_volsw, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right,\
+                 .max = xmax, .platform_max = xmax, .invert = xinvert} }
+
+/* double control with volume update */
+#define SOC_TWL6040_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax,\
+                                xinvert, tlv_array)\
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+                SNDRV_CTL_ELEM_ACCESS_READWRITE | \
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw_2r, \
+        .get = twl6040_get_volsw_2r, .put = twl6040_put_volsw_2r_vu, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
+                 .rshift = xshift, .max = xmax, .invert = xinvert}, }
+
 /*
  * MICATT volume control:
  * from -6 to 0 dB in 6 dB steps
@@ -423,9 +954,15 @@ static DECLARE_TLV_DB_SCALE(mic_preamp_tlv, -600, 600, 0);
 
 /*
  * MICGAIN volume control:
- * from 6 to 30 dB in 6 dB steps
+ * from -6 to 30 dB in 6 dB steps
+ */
+static DECLARE_TLV_DB_SCALE(mic_amp_tlv, -600, 600, 0);
+
+/*
+ * AFMGAIN volume control:
+ * from 18 to 24 dB in 6 dB steps
  */
-static DECLARE_TLV_DB_SCALE(mic_amp_tlv, 600, 600, 0);
+static DECLARE_TLV_DB_SCALE(afm_amp_tlv, 1800, 600, 0);
 
 /*
  * HSGAIN volume control:
@@ -454,8 +991,30 @@ static const char *twl6040_amicr_texts[] =
         {"Headset Mic", "Sub Mic", "Aux/FM Right", "Off"};
 
 static const struct soc_enum twl6040_enum[] = {
-        SOC_ENUM_SINGLE(TWL6040_REG_MICLCTL, 3, 3, twl6040_amicl_texts),
-        SOC_ENUM_SINGLE(TWL6040_REG_MICRCTL, 3, 3, twl6040_amicr_texts),
+        SOC_ENUM_SINGLE(TWL6040_REG_MICLCTL, 3, 4, twl6040_amicl_texts),
+        SOC_ENUM_SINGLE(TWL6040_REG_MICRCTL, 3, 4, twl6040_amicr_texts),
+};
+
+static const char *twl6040_hs_texts[] = {
+        "Off", "HS DAC", "Line-In amp"
+};
+
+static const struct soc_enum twl6040_hs_enum[] = {
+        SOC_ENUM_SINGLE(TWL6040_REG_HSLCTL, 5, ARRAY_SIZE(twl6040_hs_texts),
+                        twl6040_hs_texts),
+        SOC_ENUM_SINGLE(TWL6040_REG_HSRCTL, 5, ARRAY_SIZE(twl6040_hs_texts),
+                        twl6040_hs_texts),
+};
+
+static const char *twl6040_hf_texts[] = {
+        "Off", "HF DAC", "Line-In amp"
+};
+
+static const struct soc_enum twl6040_hf_enum[] = {
+        SOC_ENUM_SINGLE(TWL6040_REG_HFLCTL, 2, ARRAY_SIZE(twl6040_hf_texts),
+                        twl6040_hf_texts),
+        SOC_ENUM_SINGLE(TWL6040_REG_HFRCTL, 2, ARRAY_SIZE(twl6040_hf_texts),
+                        twl6040_hf_texts),
 };
 
 static const struct snd_kcontrol_new amicl_control =
@@ -465,18 +1024,18 @@ static const struct snd_kcontrol_new amicr_control =
         SOC_DAPM_ENUM("Route", twl6040_enum[1]);
 
 /* Headset DAC playback switches */
-static const struct snd_kcontrol_new hsdacl_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HSLCTL, 5, 1, 0);
+static const struct snd_kcontrol_new hsl_mux_controls =
+        SOC_DAPM_ENUM("Route", twl6040_hs_enum[0]);
 
-static const struct snd_kcontrol_new hsdacr_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HSRCTL, 5, 1, 0);
+static const struct snd_kcontrol_new hsr_mux_controls =
+        SOC_DAPM_ENUM("Route", twl6040_hs_enum[1]);
 
 /* Handsfree DAC playback switches */
-static const struct snd_kcontrol_new hfdacl_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFLCTL, 2, 1, 0);
+static const struct snd_kcontrol_new hfl_mux_controls =
+        SOC_DAPM_ENUM("Route", twl6040_hf_enum[0]);
 
-static const struct snd_kcontrol_new hfdacr_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFRCTL, 2, 1, 0);
+static const struct snd_kcontrol_new hfr_mux_controls =
+        SOC_DAPM_ENUM("Route", twl6040_hf_enum[1]);
 
 static const struct snd_kcontrol_new ep_driver_switch_controls =
         SOC_DAPM_SINGLE("Switch", TWL6040_REG_EARCTL, 0, 1, 0);
@@ -488,10 +1047,14 @@ static const struct snd_kcontrol_new twl6040_snd_controls[] = {
         SOC_DOUBLE_TLV("Capture Volume",
                 TWL6040_REG_MICGAIN, 0, 3, 4, 0, mic_amp_tlv),
 
+        /* AFM gains */
+        SOC_DOUBLE_TLV("Aux FM Volume",
+                TWL6040_REG_LINEGAIN, 0, 4, 0xF, 0, afm_amp_tlv),
+
         /* Playback gains */
-        SOC_DOUBLE_TLV("Headset Playback Volume",
+        SOC_TWL6040_DOUBLE_TLV("Headset Playback Volume",
                 TWL6040_REG_HSGAIN, 0, 4, 0xF, 1, hs_tlv),
-        SOC_DOUBLE_R_TLV("Handsfree Playback Volume",
+        SOC_TWL6040_DOUBLE_R_TLV("Handsfree Playback Volume",
                 TWL6040_REG_HFLGAIN, TWL6040_REG_HFRGAIN, 0, 0x1D, 1, hf_tlv),
         SOC_SINGLE_TLV("Earphone Playback Volume",
                 TWL6040_REG_EARCTL, 1, 0xF, 1, ep_tlv),
@@ -524,6 +1087,12 @@ static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
         SND_SOC_DAPM_PGA("MicAmpR",
                         TWL6040_REG_MICRCTL, 0, 0, NULL, 0),
 
+        /* Auxiliary FM PGAs */
+        SND_SOC_DAPM_PGA("AFMAmpL",
+                        TWL6040_REG_MICLCTL, 1, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("AFMAmpR",
+                        TWL6040_REG_MICRCTL, 1, 0, NULL, 0),
+
         /* ADCs */
         SND_SOC_DAPM_ADC("ADC Left", "Left Front Capture",
                         TWL6040_REG_MICLCTL, 2, 0),
@@ -558,29 +1127,33 @@ static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
                         twl6040_power_mode_event,
                         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 
-        /* Analog playback switches */
-        SND_SOC_DAPM_SWITCH("HSDAC Left Playback",
-                        SND_SOC_NOPM, 0, 0, &hsdacl_switch_controls),
-        SND_SOC_DAPM_SWITCH("HSDAC Right Playback",
-                        SND_SOC_NOPM, 0, 0, &hsdacr_switch_controls),
-        SND_SOC_DAPM_SWITCH("HFDAC Left Playback",
-                        SND_SOC_NOPM, 0, 0, &hfdacl_switch_controls),
-        SND_SOC_DAPM_SWITCH("HFDAC Right Playback",
-                        SND_SOC_NOPM, 0, 0, &hfdacr_switch_controls),
+        SND_SOC_DAPM_MUX("HF Left Playback",
+                        SND_SOC_NOPM, 0, 0, &hfl_mux_controls),
+        SND_SOC_DAPM_MUX("HF Right Playback",
+                        SND_SOC_NOPM, 0, 0, &hfr_mux_controls),
+        /* Analog playback Muxes */
+        SND_SOC_DAPM_MUX("HS Left Playback",
+                        SND_SOC_NOPM, 0, 0, &hsl_mux_controls),
+        SND_SOC_DAPM_MUX("HS Right Playback",
+                        SND_SOC_NOPM, 0, 0, &hsr_mux_controls),
 
         /* Analog playback drivers */
         SND_SOC_DAPM_PGA_E("Handsfree Left Driver",
                         TWL6040_REG_HFLCTL, 4, 0, NULL, 0,
-                        twl6040_power_mode_event,
-                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+                        pga_event,
+                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
         SND_SOC_DAPM_PGA_E("Handsfree Right Driver",
                         TWL6040_REG_HFRCTL, 4, 0, NULL, 0,
-                        twl6040_power_mode_event,
-                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
-        SND_SOC_DAPM_PGA("Headset Left Driver",
-                        TWL6040_REG_HSLCTL, 2, 0, NULL, 0),
-        SND_SOC_DAPM_PGA("Headset Right Driver",
-                        TWL6040_REG_HSRCTL, 2, 0, NULL, 0),
+                        pga_event,
+                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+        SND_SOC_DAPM_PGA_E("Headset Left Driver",
+                        TWL6040_REG_HSLCTL, 2, 0, NULL, 0,
+                        pga_event,
+                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+        SND_SOC_DAPM_PGA_E("Headset Right Driver",
+                        TWL6040_REG_HSRCTL, 2, 0, NULL, 0,
+                        pga_event,
+                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
         SND_SOC_DAPM_SWITCH_E("Earphone Driver",
                         SND_SOC_NOPM, 0, 0, &ep_driver_switch_controls,
                         twl6040_power_mode_event,
@@ -610,12 +1183,18 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"ADC Left", NULL, "MicAmpL"},
         {"ADC Right", NULL, "MicAmpR"},
 
-        /* Headset playback path */
-        {"HSDAC Left Playback", "Switch", "HSDAC Left"},
-        {"HSDAC Right Playback", "Switch", "HSDAC Right"},
+        /* AFM path */
+        {"AFMAmpL", "NULL", "AFML"},
+        {"AFMAmpR", "NULL", "AFMR"},
+
+        {"HS Left Playback", "HS DAC", "HSDAC Left"},
+        {"HS Left Playback", "Line-In amp", "AFMAmpL"},
 
-        {"Headset Left Driver", NULL, "HSDAC Left Playback"},
-        {"Headset Right Driver", NULL, "HSDAC Right Playback"},
+        {"HS Right Playback", "HS DAC", "HSDAC Right"},
+        {"HS Right Playback", "Line-In amp", "AFMAmpR"},
+
+        {"Headset Left Driver", "NULL", "HS Left Playback"},
+        {"Headset Right Driver", "NULL", "HS Right Playback"},
 
         {"HSOL", NULL, "Headset Left Driver"},
         {"HSOR", NULL, "Headset Right Driver"},
@@ -624,12 +1203,14 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Earphone Driver", "Switch", "HSDAC Left"},
         {"EP", NULL, "Earphone Driver"},
 
-        /* Handsfree playback path */
-        {"HFDAC Left Playback", "Switch", "HFDAC Left"},
-        {"HFDAC Right Playback", "Switch", "HFDAC Right"},
+        {"HF Left Playback", "HF DAC", "HFDAC Left"},
+        {"HF Left Playback", "Line-In amp", "AFMAmpL"},
+
+        {"HF Right Playback", "HF DAC", "HFDAC Right"},
+        {"HF Right Playback", "Line-In amp", "AFMAmpR"},
 
-        {"HFDAC Left PGA", NULL, "HFDAC Left Playback"},
-        {"HFDAC Right PGA", NULL, "HFDAC Right Playback"},
+        {"HFDAC Left PGA", NULL, "HF Left Playback"},
+        {"HFDAC Right PGA", NULL, "HF Right Playback"},
 
         {"Handsfree Left Driver", "Switch", "HFDAC Left PGA"},
         {"Handsfree Right Driver", "Switch", "HFDAC Right PGA"},
@@ -658,10 +1239,10 @@ static int twl6040_power_up_completion(struct snd_soc_codec *codec,
         u8 intid;
 
         time_left = wait_for_completion_timeout(&priv->ready,
-                                msecs_to_jiffies(48));
+                                msecs_to_jiffies(144));
 
         if (!time_left) {
-                twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &intid,
+                twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &intid,
                                                         TWL6040_REG_INTID);
                 if (!(intid & TWL6040_READYINT)) {
                         dev_err(codec->dev, "timeout waiting for READYINT\n");
@@ -712,6 +1293,15 @@ static int twl6040_set_bias_level(struct snd_soc_codec *codec,
 
                 /* initialize vdd/vss registers with reg_cache */
                 twl6040_init_vdd_regs(codec);
+
+                /* Set external boost GPO */
+                twl6040_write(codec, TWL6040_REG_GPOCTL, 0x02);
+
+                /* Set initial minimal gain values */
+                twl6040_write(codec, TWL6040_REG_HSGAIN, 0xFF);
+                twl6040_write(codec, TWL6040_REG_EARCTL, 0x1E);
+                twl6040_write(codec, TWL6040_REG_HFLGAIN, 0x1D);
+                twl6040_write(codec, TWL6040_REG_HFRGAIN, 0x1D);
                 break;
         case SND_SOC_BIAS_OFF:
                 if (!priv->codec_powered)
@@ -771,23 +1361,6 @@ static int twl6040_startup(struct snd_pcm_substream *substream,
         struct snd_soc_codec *codec = rtd->codec;
         struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
-        if (!priv->sysclk) {
-                dev_err(codec->dev,
-                        "no mclk configured, call set_sysclk() on init\n");
-                return -EINVAL;
-        }
-
-        /*
-         * capture is not supported at 17.64 MHz,
-         * it's reserved for headset low-power playback scenario
-         */
-        if ((priv->sysclk == 17640000) && substream->stream) {
-                dev_err(codec->dev,
-                        "capture mode is not supported at %dHz\n",
-                        priv->sysclk);
-                return -EINVAL;
-        }
-
         snd_pcm_hw_constraint_list(substream->runtime, 0,
                                 SNDRV_PCM_HW_PARAM_RATE,
                                 priv->sysclk_constraints);
@@ -813,10 +1386,17 @@ static int twl6040_hw_params(struct snd_pcm_substream *substream,
 
         rate = params_rate(params);
         switch (rate) {
+        case 11250:
+        case 22500:
+        case 44100:
         case 88200:
                 lppllctl |= TWL6040_LPLLFIN;
                 priv->sysclk = 17640000;
                 break;
+        case 8000:
+        case 16000:
+        case 32000:
+        case 48000:
         case 96000:
                 lppllctl &= ~TWL6040_LPLLFIN;
                 priv->sysclk = 19200000;
@@ -831,31 +1411,37 @@ static int twl6040_hw_params(struct snd_pcm_substream *substream,
         return 0;
 }
 
-static int twl6040_trigger(struct snd_pcm_substream *substream,
-                        int cmd, struct snd_soc_dai *dai)
+static int twl6040_prepare(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 twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
 
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-                /*
-                 * low-power playback mode is restricted
-                 * for headset path only
-                 */
-                if ((priv->sysclk == 17640000) && priv->non_lp) {
+        if (!priv->sysclk) {
+                dev_err(codec->dev,
+                        "no mclk configured, call set_sysclk() on init\n");
+                return -EINVAL;
+        }
+
+        /*
+         * capture is not supported at 17.64 MHz,
+         * it's reserved for headset low-power playback scenario
+         */
+        if ((priv->sysclk == 17640000) &&
+                        substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
+                dev_err(codec->dev,
+                        "capture mode is not supported at %dHz\n",
+                        priv->sysclk);
+                return -EINVAL;
+        }
+
+        if ((priv->sysclk == 17640000) && priv->non_lp) {
                         dev_err(codec->dev,
                                 "some enabled paths aren't supported at %dHz\n",
                                 priv->sysclk);
                         return -EPERM;
-                }
-                break;
-        default:
-                break;
         }
-
         return 0;
 }
 
@@ -969,7 +1555,7 @@ static int twl6040_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 static struct snd_soc_dai_ops twl6040_dai_ops = {
         .startup        = twl6040_startup,
         .hw_params      = twl6040_hw_params,
-        .trigger        = twl6040_trigger,
+        .prepare        = twl6040_prepare,
         .set_sysclk     = twl6040_set_dai_sysclk,
 };
 
@@ -1003,6 +1589,7 @@ static int twl6040_suspend(struct snd_soc_codec *codec, pm_message_t state)
 static int twl6040_resume(struct snd_soc_codec *codec)
 {
         twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        twl6040_set_bias_level(codec, codec->dapm.suspend_bias_level);
 
         return 0;
 }
@@ -1017,24 +1604,41 @@ static int twl6040_probe(struct snd_soc_codec *codec)
         struct twl6040_data *priv;
         int audpwron, naudint;
         int ret = 0;
+        u8 icrev, intmr = TWL6040_ALLINT_MSK;
 
         priv = kzalloc(sizeof(struct twl6040_data), GFP_KERNEL);
         if (priv == NULL)
                 return -ENOMEM;
         snd_soc_codec_set_drvdata(codec, priv);
 
-        if (twl_codec) {
+        priv->codec = codec;
+
+        twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &icrev, TWL6040_REG_ASICREV);
+
+        if (twl_codec && (icrev > 0))
                 audpwron = twl_codec->audpwron_gpio;
-                naudint = twl_codec->naudint_irq;
-        } else {
+        else
                 audpwron = -EINVAL;
+
+        if (twl_codec)
+                naudint = twl_codec->naudint_irq;
+        else
                 naudint = 0;
-        }
 
         priv->audpwron = audpwron;
         priv->naudint = naudint;
+        priv->workqueue = create_singlethread_workqueue("twl6040-codec");
+
+        if (!priv->workqueue)
+                goto work_err;
+
+        INIT_DELAYED_WORK(&priv->delayed_work, twl6040_accessory_work);
+
+        mutex_init(&priv->mutex);
 
         init_completion(&priv->ready);
+        init_completion(&priv->headset.ramp_done);
+        init_completion(&priv->handsfree.ramp_done);
 
         if (gpio_is_valid(audpwron)) {
                 ret = gpio_request(audpwron, "audpwron");
@@ -1046,7 +1650,14 @@ static int twl6040_probe(struct snd_soc_codec *codec)
                         goto gpio2_err;
 
                 priv->codec_powered = 0;
+
+                /* enable only codec ready interrupt */
+                intmr &= ~(TWL6040_READYMSK | TWL6040_PLUGMSK);
+
+                /* reset interrupt status to allow correct power up sequence */
+                twl6040_read_reg_volatile(codec, TWL6040_REG_INTID);
         }
+        twl6040_write(codec, TWL6040_REG_INTMR, intmr);
 
         if (naudint) {
                 /* audio interrupt */
@@ -1056,25 +1667,29 @@ static int twl6040_probe(struct snd_soc_codec *codec)
                                 "twl6040_codec", codec);
                 if (ret)
                         goto gpio2_err;
-        } else {
-                if (gpio_is_valid(audpwron)) {
-                        /* enable only codec ready interrupt */
-                        twl6040_write_reg_cache(codec, TWL6040_REG_INTMR,
-                                        ~TWL6040_READYMSK & TWL6040_ALLINT_MSK);
-                } else {
-                        /* no interrupts at all */
-                        twl6040_write_reg_cache(codec, TWL6040_REG_INTMR,
-                                                TWL6040_ALLINT_MSK);
-                }
         }
 
         /* init vio registers */
         twl6040_init_vio_regs(codec);
 
+        priv->hf_workqueue = create_singlethread_workqueue("twl6040-hf");
+        if (priv->hf_workqueue == NULL) {
+                ret = -ENOMEM;
+                goto irq_err;
+        }
+        priv->hs_workqueue = create_singlethread_workqueue("twl6040-hs");
+        if (priv->hs_workqueue == NULL) {
+                ret = -ENOMEM;
+                goto wq_err;
+        }
+
+        INIT_DELAYED_WORK(&priv->hs_delayed_work, twl6040_pga_hs_work);
+        INIT_DELAYED_WORK(&priv->hf_delayed_work, twl6040_pga_hf_work);
+
         /* power on device */
         ret = twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
         if (ret)
-                goto irq_err;
+                goto bias_err;
 
         snd_soc_add_controls(codec, twl6040_snd_controls,
                                 ARRAY_SIZE(twl6040_snd_controls));
@@ -1082,6 +1697,10 @@ static int twl6040_probe(struct snd_soc_codec *codec)
 
         return 0;
 
+bias_err:
+        destroy_workqueue(priv->hs_workqueue);
+wq_err:
+        destroy_workqueue(priv->hf_workqueue);
 irq_err:
         if (naudint)
                 free_irq(naudint, codec);
@@ -1089,6 +1708,8 @@ gpio2_err:
         if (gpio_is_valid(audpwron))
                 gpio_free(audpwron);
 gpio1_err:
+        destroy_workqueue(priv->workqueue);
+work_err:
         kfree(priv);
         return ret;
 }
@@ -1107,6 +1728,9 @@ static int twl6040_remove(struct snd_soc_codec *codec)
         if (naudint)
                 free_irq(naudint, codec);
 
+        destroy_workqueue(priv->workqueue);
+        destroy_workqueue(priv->hf_workqueue);
+        destroy_workqueue(priv->hs_workqueue);
         kfree(priv);
 
         return 0;