CHROMIUM: ASoC: Import entire upstream ASoC tree

sound/soc/codecs/tlv320dac33.c

 /*
  * ALSA SoC Texas Instruments TLV320DAC33 codec driver
  *
  * Author:      Peter Ujfalusi <peter.ujfalusi@nokia.com>
  *
  * Copyright:   (C) 2009 Nokia Corporation
  *
  * 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 18 matching lines @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.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>
 
 #include <sound/tlv320dac33-plat.h>
 #include "tlv320dac33.h"
 
-#define DAC33_BUFFER_SIZE_BYTES         24576   /* bytes, 12288 16 bit words,
-                                                 * 6144 stereo */
-#define DAC33_BUFFER_SIZE_SAMPLES       6144
-
-#define NSAMPLE_MAX             5700
-
-#define MODE7_LTHR              10
-#define MODE7_UTHR              (DAC33_BUFFER_SIZE_SAMPLES - 10)
+/*
+ * The internal FIFO is 24576 bytes long
+ * It can be configured to hold 16bit or 24bit samples
+ * In 16bit configuration the FIFO can hold 6144 stereo samples
+ * In 24bit configuration the FIFO can hold 4096 stereo samples
+ */
+#define DAC33_FIFO_SIZE_16BIT   6144
+#define DAC33_FIFO_SIZE_24BIT   4096
+#define DAC33_MODE7_MARGIN      10      /* Safety margin for FIFO in Mode7 */
 
 #define BURST_BASEFREQ_HZ       49152000
 
 #define SAMPLES_TO_US(rate, samples) \
         (1000000000 / ((rate * 1000) / samples))
 
 #define US_TO_SAMPLES(rate, us) \
         (rate / (1000000 / (us < 1000000 ? us : 1000000)))
 
 #define UTHR_FROM_PERIOD_SIZE(samples, playrate, burstrate) \
@@ skipping 29 matching lines @@
         struct work_struct work;
         struct snd_soc_codec *codec;
         struct regulator_bulk_data supplies[DAC33_NUM_SUPPLIES];
         struct snd_pcm_substream *substream;
         int power_gpio;
         int chip_power;
         int irq;
         unsigned int refclk;
 
         unsigned int alarm_threshold;   /* set to be half of LATENCY_TIME_MS */
-        unsigned int nsample_min;       /* nsample should not be lower than
-                                         * this */
-        unsigned int nsample_max;       /* nsample should not be higher than
-                                         * this */
         enum dac33_fifo_modes fifo_mode;/* FIFO mode selection */
+        unsigned int fifo_size;         /* Size of the FIFO in samples */
         unsigned int nsample;           /* burst read amount from host */
         int mode1_latency;              /* latency caused by the i2c writes in
                                          * us */
-        int auto_fifo_config;           /* Configure the FIFO based on the
-                                         * period size */
         u8 burst_bclkdiv;               /* BCLK divider value in burst mode */
         unsigned int burst_rate;        /* Interface speed in Burst modes */
 
         int keep_bclk;                  /* Keep the BCLK continuously running
                                          * in FIFO modes */
         spinlock_t lock;
         unsigned long long t_stamp1;    /* Time stamp for FIFO modes to */
         unsigned long long t_stamp2;    /* calculate the FIFO caused delay */
 
         unsigned int mode1_us_burst;    /* Time to burst read n number of
@@ skipping 173 matching lines @@
         return ret;
 }
 
 static void dac33_init_chip(struct snd_soc_codec *codec)
 {
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
         if (unlikely(!dac33->chip_power))
                 return;
 
-        /* 44-46: DAC Control Registers */
         /* A : DAC sample rate Fsref/1.5 */
         dac33_write(codec, DAC33_DAC_CTRL_A, DAC33_DACRATE(0));
         /* B : DAC src=normal, not muted */
         dac33_write(codec, DAC33_DAC_CTRL_B, DAC33_DACSRCR_RIGHT |
                                              DAC33_DACSRCL_LEFT);
         /* C : (defaults) */
         dac33_write(codec, DAC33_DAC_CTRL_C, 0x00);
 
         /* 73 : volume soft stepping control,
          clock source = internal osc (?) */
         dac33_write(codec, DAC33_ANA_VOL_SOFT_STEP_CTRL, DAC33_VOLCLKEN);
 
-        dac33_write(codec, DAC33_PWR_CTRL, DAC33_PDNALLB);
-
         /* Restore only selected registers (gains mostly) */
         dac33_write(codec, DAC33_LDAC_DIG_VOL_CTRL,
                     dac33_read_reg_cache(codec, DAC33_LDAC_DIG_VOL_CTRL));
         dac33_write(codec, DAC33_RDAC_DIG_VOL_CTRL,
                     dac33_read_reg_cache(codec, DAC33_RDAC_DIG_VOL_CTRL));
 
         dac33_write(codec, DAC33_LINEL_TO_LLO_VOL,
                     dac33_read_reg_cache(codec, DAC33_LINEL_TO_LLO_VOL));
         dac33_write(codec, DAC33_LINER_TO_RLO_VOL,
                     dac33_read_reg_cache(codec, DAC33_LINER_TO_RLO_VOL));
+
+        dac33_write(codec, DAC33_OUT_AMP_CTRL,
+                    dac33_read_reg_cache(codec, DAC33_OUT_AMP_CTRL));
+
 }
 
 static inline int dac33_read_id(struct snd_soc_codec *codec)
 {
         int i, ret = 0;
         u8 reg;
 
         for (i = 0; i < 3; i++) {
                 ret = dac33_read(codec, DAC33_DEVICE_ID_MSB + i, &reg);
                 if (ret < 0)
                         break;
         }
 
         return ret;
 }
 
 static inline void dac33_soft_power(struct snd_soc_codec *codec, int power)
 {
         u8 reg;
 
         reg = dac33_read_reg_cache(codec, DAC33_PWR_CTRL);
         if (power)
                 reg |= DAC33_PDNALLB;
         else
                 reg &= ~(DAC33_PDNALLB | DAC33_OSCPDNB |
                          DAC33_DACRPDNB | DAC33_DACLPDNB);
         dac33_write(codec, DAC33_PWR_CTRL, reg);
 }
 
+static inline void dac33_disable_digital(struct snd_soc_codec *codec)
+{
+        u8 reg;
+
+        /* Stop the DAI clock */
+        reg = dac33_read_reg_cache(codec, DAC33_SER_AUDIOIF_CTRL_B);
+        reg &= ~DAC33_BCLKON;
+        dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_B, reg);
+
+        /* Power down the Oscillator, and DACs */
+        reg = dac33_read_reg_cache(codec, DAC33_PWR_CTRL);
+        reg &= ~(DAC33_OSCPDNB | DAC33_DACRPDNB | DAC33_DACLPDNB);
+        dac33_write(codec, DAC33_PWR_CTRL, reg);
+}
+
 static int dac33_hard_power(struct snd_soc_codec *codec, int power)
 {
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
         int ret = 0;
 
         mutex_lock(&dac33->mutex);
 
         /* Safety check */
         if (unlikely(power == dac33->chip_power)) {
                 dev_dbg(codec->dev, "Trying to set the same power state: %s\n",
@@ skipping 28 matching lines @@
                 }
 
                 dac33->chip_power = 0;
         }
 
 exit:
         mutex_unlock(&dac33->mutex);
         return ret;
 }
 
-static int playback_event(struct snd_soc_dapm_widget *w,
+static int dac33_playback_event(struct snd_soc_dapm_widget *w,
                 struct snd_kcontrol *kcontrol, int event)
 {
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(w->codec);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
                 if (likely(dac33->substream)) {
                         dac33_calculate_times(dac33->substream);
                         dac33_prepare_chip(dac33->substream);
                 }
                 break;
+        case SND_SOC_DAPM_POST_PMD:
+                dac33_disable_digital(w->codec);
+                break;
         }
         return 0;
 }
 
-static int dac33_get_nsample(struct snd_kcontrol *kcontrol,
-                         struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
-
-        ucontrol->value.integer.value[0] = dac33->nsample;
-
-        return 0;
-}
-
-static int dac33_set_nsample(struct snd_kcontrol *kcontrol,
-                         struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
-        int ret = 0;
-
-        if (dac33->nsample == ucontrol->value.integer.value[0])
-                return 0;
-
-        if (ucontrol->value.integer.value[0] < dac33->nsample_min ||
-            ucontrol->value.integer.value[0] > dac33->nsample_max) {
-                ret = -EINVAL;
-        } else {
-                dac33->nsample = ucontrol->value.integer.value[0];
-                /* Re calculate the burst time */
-                dac33->mode1_us_burst = SAMPLES_TO_US(dac33->burst_rate,
-                                                      dac33->nsample);
-        }
-
-        return ret;
-}
-
-static int dac33_get_uthr(struct snd_kcontrol *kcontrol,
-                         struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
-
-        ucontrol->value.integer.value[0] = dac33->uthr;
-
-        return 0;
-}
-
-static int dac33_set_uthr(struct snd_kcontrol *kcontrol,
-                         struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
-        int ret = 0;
-
-        if (dac33->substream)
-                return -EBUSY;
-
-        if (dac33->uthr == ucontrol->value.integer.value[0])
-                return 0;
-
-        if (ucontrol->value.integer.value[0] < (MODE7_LTHR + 10) ||
-            ucontrol->value.integer.value[0] > MODE7_UTHR)
-                ret = -EINVAL;
-        else
-                dac33->uthr = ucontrol->value.integer.value[0];
-
-        return ret;
-}
-
 static int dac33_get_fifo_mode(struct snd_kcontrol *kcontrol,
                          struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
         ucontrol->value.integer.value[0] = dac33->fifo_mode;
 
         return 0;
 }
@@ skipping 64 matching lines @@
                  DAC33_LINEL_TO_LLO_VOL, DAC33_LINER_TO_RLO_VOL, 0, 127, 1),
         SOC_ENUM("Left Line Output Gain", l_lineout_gain_enum),
         SOC_ENUM("Right Line Output Gain", r_lineout_gain_enum),
 };
 
 static const struct snd_kcontrol_new dac33_mode_snd_controls[] = {
         SOC_ENUM_EXT("FIFO Mode", dac33_fifo_mode_enum,
                  dac33_get_fifo_mode, dac33_set_fifo_mode),
 };
 
-static const struct snd_kcontrol_new dac33_fifo_snd_controls[] = {
-        SOC_SINGLE_EXT("nSample", 0, 0, 5900, 0,
-                dac33_get_nsample, dac33_set_nsample),
-        SOC_SINGLE_EXT("UTHR", 0, 0, MODE7_UTHR, 0,
-                 dac33_get_uthr, dac33_set_uthr),
-};
-
 /* Analog bypass */
 static const struct snd_kcontrol_new dac33_dapm_abypassl_control =
         SOC_DAPM_SINGLE("Switch", DAC33_LINEL_TO_LLO_VOL, 7, 1, 1);
 
 static const struct snd_kcontrol_new dac33_dapm_abypassr_control =
         SOC_DAPM_SINGLE("Switch", DAC33_LINER_TO_RLO_VOL, 7, 1, 1);
 
+/* LOP L/R invert selection */
+static const char *dac33_lr_lom_texts[] = {"DAC", "LOP"};
+
+static const struct soc_enum dac33_left_lom_enum =
+        SOC_ENUM_SINGLE(DAC33_OUT_AMP_CTRL, 3,
+                        ARRAY_SIZE(dac33_lr_lom_texts),
+                        dac33_lr_lom_texts);
+
+static const struct snd_kcontrol_new dac33_dapm_left_lom_control =
+SOC_DAPM_ENUM("Route", dac33_left_lom_enum);
+
+static const struct soc_enum dac33_right_lom_enum =
+        SOC_ENUM_SINGLE(DAC33_OUT_AMP_CTRL, 2,
+                        ARRAY_SIZE(dac33_lr_lom_texts),
+                        dac33_lr_lom_texts);
+
+static const struct snd_kcontrol_new dac33_dapm_right_lom_control =
+SOC_DAPM_ENUM("Route", dac33_right_lom_enum);
+
 static const struct snd_soc_dapm_widget dac33_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("LEFT_LO"),
         SND_SOC_DAPM_OUTPUT("RIGHT_LO"),
 
         SND_SOC_DAPM_INPUT("LINEL"),
         SND_SOC_DAPM_INPUT("LINER"),
 
-        SND_SOC_DAPM_DAC("DACL", "Left Playback", DAC33_LDAC_PWR_CTRL, 2, 0),
-        SND_SOC_DAPM_DAC("DACR", "Right Playback", DAC33_RDAC_PWR_CTRL, 2, 0),
+        SND_SOC_DAPM_DAC("DACL", "Left Playback", SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("DACR", "Right Playback", SND_SOC_NOPM, 0, 0),
 
         /* Analog bypass */
         SND_SOC_DAPM_SWITCH("Analog Left Bypass", SND_SOC_NOPM, 0, 0,
                                 &dac33_dapm_abypassl_control),
         SND_SOC_DAPM_SWITCH("Analog Right Bypass", SND_SOC_NOPM, 0, 0,
                                 &dac33_dapm_abypassr_control),
 
-        SND_SOC_DAPM_REG(snd_soc_dapm_mixer, "Output Left Amp Power",
+        SND_SOC_DAPM_MUX("Left LOM Inverted From", SND_SOC_NOPM, 0, 0,
+                &dac33_dapm_left_lom_control),
+        SND_SOC_DAPM_MUX("Right LOM Inverted From", SND_SOC_NOPM, 0, 0,
+                &dac33_dapm_right_lom_control),
+        /*
+         * For DAPM path, when only the anlog bypass path is enabled, and the
+         * LOP inverted from the corresponding DAC side.
+         * This is needed, so we can attach the DAC power supply in this case.
+         */
+        SND_SOC_DAPM_PGA("Left Bypass PGA", SND_SOC_NOPM, 0, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Right Bypass PGA", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+        SND_SOC_DAPM_REG(snd_soc_dapm_mixer, "Output Left Amplifier",
                          DAC33_OUT_AMP_PWR_CTRL, 6, 3, 3, 0),
-        SND_SOC_DAPM_REG(snd_soc_dapm_mixer, "Output Right Amp Power",
+        SND_SOC_DAPM_REG(snd_soc_dapm_mixer, "Output Right Amplifier",
                          DAC33_OUT_AMP_PWR_CTRL, 4, 3, 3, 0),
 
-        SND_SOC_DAPM_PRE("Prepare Playback", playback_event),
+        SND_SOC_DAPM_SUPPLY("Left DAC Power",
+                            DAC33_LDAC_PWR_CTRL, 2, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("Right DAC Power",
+                            DAC33_RDAC_PWR_CTRL, 2, 0, NULL, 0),
+
+        SND_SOC_DAPM_PRE("Pre Playback", dac33_playback_event),
+        SND_SOC_DAPM_POST("Post Playback", dac33_playback_event),
 };
 
 static const struct snd_soc_dapm_route audio_map[] = {
         /* Analog bypass */
         {"Analog Left Bypass", "Switch", "LINEL"},
         {"Analog Right Bypass", "Switch", "LINER"},
 
-        {"Output Left Amp Power", NULL, "DACL"},
-        {"Output Right Amp Power", NULL, "DACR"},
+        {"Output Left Amplifier", NULL, "DACL"},
+        {"Output Right Amplifier", NULL, "DACR"},
 
-        {"Output Left Amp Power", NULL, "Analog Left Bypass"},
-        {"Output Right Amp Power", NULL, "Analog Right Bypass"},
+        {"Left Bypass PGA", NULL, "Analog Left Bypass"},
+        {"Right Bypass PGA", NULL, "Analog Right Bypass"},
+
+        {"Left LOM Inverted From", "DAC", "Left Bypass PGA"},
+        {"Right LOM Inverted From", "DAC", "Right Bypass PGA"},
+        {"Left LOM Inverted From", "LOP", "Analog Left Bypass"},
+        {"Right LOM Inverted From", "LOP", "Analog Right Bypass"},
+
+        {"Output Left Amplifier", NULL, "Left LOM Inverted From"},
+        {"Output Right Amplifier", NULL, "Right LOM Inverted From"},
+
+        {"DACL", NULL, "Left DAC Power"},
+        {"DACR", NULL, "Right DAC Power"},
+
+        {"Left Bypass PGA", NULL, "Left DAC Power"},
+        {"Right Bypass PGA", NULL, "Right DAC Power"},
 
         /* output */
-        {"LEFT_LO", NULL, "Output Left Amp Power"},
-        {"RIGHT_LO", NULL, "Output Right Amp Power"},
+        {"LEFT_LO", NULL, "Output Left Amplifier"},
+        {"RIGHT_LO", NULL, "Output Right Amplifier"},
 };
 
 static int dac33_add_widgets(struct snd_soc_codec *codec)
 {
-        snd_soc_dapm_new_controls(codec, dac33_dapm_widgets,
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+
+        snd_soc_dapm_new_controls(dapm, dac33_dapm_widgets,
                                   ARRAY_SIZE(dac33_dapm_widgets));
-
         /* set up audio path interconnects */
-        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+        snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
 
         return 0;
 }
 
 static int dac33_set_bias_level(struct snd_soc_codec *codec,
                                 enum snd_soc_bias_level level)
 {
+        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
-                dac33_soft_power(codec, 1);
+                if (!dac33->substream)
+                        dac33_soft_power(codec, 1);
                 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) {
                         /* Coming from OFF, switch on the codec */
                         ret = dac33_hard_power(codec, 1);
                         if (ret != 0)
                                 return ret;
 
                         dac33_init_chip(codec);
                 }
                 break;
         case SND_SOC_BIAS_OFF:
                 /* Do not power off, when the codec is already off */
-                if (codec->bias_level == SND_SOC_BIAS_OFF)
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
                         return 0;
                 ret = dac33_hard_power(codec, 0);
                 if (ret != 0)
                         return ret;
                 break;
         }
-        codec->bias_level = level;
+        codec->dapm.bias_level = level;
 
         return 0;
 }
 
 static inline void dac33_prefill_handler(struct tlv320dac33_priv *dac33)
 {
         struct snd_soc_codec *codec = dac33->codec;
         unsigned int delay;
 
         switch (dac33->fifo_mode) {
@@ skipping 17 matching lines @@
                 break;
         case DAC33_FIFO_MODE7:
                 /* Take the timestamp */
                 spin_lock_irq(&dac33->lock);
                 dac33->t_stamp1 = ktime_to_us(ktime_get());
                 /* Move back the timestamp with drain time */
                 dac33->t_stamp1 -= dac33->mode7_us_to_lthr;
                 spin_unlock_irq(&dac33->lock);
 
                 dac33_write16(codec, DAC33_PREFILL_MSB,
-                                DAC33_THRREG(MODE7_LTHR));
+                                DAC33_THRREG(DAC33_MODE7_MARGIN));
 
                 /* Enable Upper Threshold IRQ */
                 dac33_write(codec, DAC33_FIFO_IRQ_MASK, DAC33_MUT);
                 break;
         default:
                 dev_warn(codec->dev, "Unhandled FIFO mode: %d\n",
                                                         dac33->fifo_mode);
                 break;
         }
 }
@@ skipping 89 matching lines @@
 static int dac33_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 tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
         /* Stream started, save the substream pointer */
         dac33->substream = substream;
 
+        snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24);
+
         return 0;
 }
 
 static void dac33_shutdown(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 tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
         dac33->substream = NULL;
-
-        /* Reset the nSample restrictions */
-        dac33->nsample_min = 0;
-        dac33->nsample_max = NSAMPLE_MAX;
 }
 
+#define CALC_BURST_RATE(bclkdiv, bclk_per_sample) \
+        (BURST_BASEFREQ_HZ / bclkdiv / bclk_per_sample)
 static int dac33_hw_params(struct snd_pcm_substream *substream,
                            struct snd_pcm_hw_params *params,
                            struct snd_soc_dai *dai)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_codec *codec = rtd->codec;
+        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
         /* Check parameters for validity */
         switch (params_rate(params)) {
         case 44100:
         case 48000:
                 break;
         default:
                 dev_err(codec->dev, "unsupported rate %d\n",
                         params_rate(params));
                 return -EINVAL;
         }
 
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
+                dac33->fifo_size = DAC33_FIFO_SIZE_16BIT;
+                dac33->burst_rate = CALC_BURST_RATE(dac33->burst_bclkdiv, 32);
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                dac33->fifo_size = DAC33_FIFO_SIZE_24BIT;
+                dac33->burst_rate = CALC_BURST_RATE(dac33->burst_bclkdiv, 64);
                 break;
         default:
                 dev_err(codec->dev, "unsupported format %d\n",
                         params_format(params));
                 return -EINVAL;
         }
 
         return 0;
 }
 
@@ skipping 34 matching lines @@
         /* Read FIFO control A, and clear FIFO flush bit */
         fifoctrl_a = dac33_read_reg_cache(codec, DAC33_FIFO_CTRL_A);
         fifoctrl_a &= ~DAC33_FIFOFLUSH;
 
         fifoctrl_a &= ~DAC33_WIDTH;
         switch (substream->runtime->format) {
         case SNDRV_PCM_FORMAT_S16_LE:
                 aictrl_a |= (DAC33_NCYCL_16 | DAC33_WLEN_16);
                 fifoctrl_a |= DAC33_WIDTH;
                 break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                aictrl_a |= (DAC33_NCYCL_32 | DAC33_WLEN_24);
+                break;
         default:
                 dev_err(codec->dev, "unsupported format %d\n",
                         substream->runtime->format);
                 return -EINVAL;
         }
 
         mutex_lock(&dac33->mutex);
 
         if (!dac33->chip_power) {
                 /*
@@ skipping 114 matching lines @@
          * 1: 1
          * 2: 2
          * ...
          * 254: 254
          * 255: 255
          */
         if (dac33->fifo_mode)
                 dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_C,
                                                         dac33->burst_bclkdiv);
         else
-                dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_C, 32);
+                if (substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE)
+                        dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_C, 32);
+                else
+                        dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_C, 16);
 
         switch (dac33->fifo_mode) {
         case DAC33_FIFO_MODE1:
                 dac33_write16(codec, DAC33_ATHR_MSB,
                               DAC33_THRREG(dac33->alarm_threshold));
                 break;
         case DAC33_FIFO_MODE7:
                 /*
                  * Configure the threshold levels, and leave 10 sample space
                  * at the bottom, and also at the top of the FIFO
                  */
                 dac33_write16(codec, DAC33_UTHR_MSB, DAC33_THRREG(dac33->uthr));
-                dac33_write16(codec, DAC33_LTHR_MSB, DAC33_THRREG(MODE7_LTHR));
+                dac33_write16(codec, DAC33_LTHR_MSB,
+                              DAC33_THRREG(DAC33_MODE7_MARGIN));
                 break;
         default:
                 break;
         }
 
         mutex_unlock(&dac33->mutex);
 
         return 0;
 }
 
 static void dac33_calculate_times(struct snd_pcm_substream *substream)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_codec *codec = rtd->codec;
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
         unsigned int period_size = substream->runtime->period_size;
         unsigned int rate = substream->runtime->rate;
         unsigned int nsample_limit;
 
         /* In bypass mode we don't need to calculate */
         if (!dac33->fifo_mode)
                 return;
 
         switch (dac33->fifo_mode) {
         case DAC33_FIFO_MODE1:
                 /* Number of samples under i2c latency */
                 dac33->alarm_threshold = US_TO_SAMPLES(rate,
                                                 dac33->mode1_latency);
-                nsample_limit = DAC33_BUFFER_SIZE_SAMPLES -
-                                dac33->alarm_threshold;
+                nsample_limit = dac33->fifo_size - dac33->alarm_threshold;
 
-                if (dac33->auto_fifo_config) {
-                        if (period_size <= dac33->alarm_threshold)
-                                /*
-                                 * Configure nSamaple to number of periods,
-                                 * which covers the latency requironment.
-                                 */
-                                dac33->nsample = period_size *
-                                       ((dac33->alarm_threshold / period_size) +
-                                       (dac33->alarm_threshold % period_size ?
-                                       1 : 0));
-                        else if (period_size > nsample_limit)
-                                dac33->nsample = nsample_limit;
-                        else
-                                dac33->nsample = period_size;
-                } else {
-                        /* nSample time shall not be shorter than i2c latency */
-                        dac33->nsample_min = dac33->alarm_threshold;
+                if (period_size <= dac33->alarm_threshold)
                         /*
-                         * nSample should not be bigger than alsa buffer minus
-                         * size of one period to avoid overruns
+                         * Configure nSamaple to number of periods,
+                         * which covers the latency requironment.
                          */
-                        dac33->nsample_max = substream->runtime->buffer_size -
-                                                period_size;
-
-                        if (dac33->nsample_max > nsample_limit)
-                                dac33->nsample_max = nsample_limit;
-
-                        /* Correct the nSample if it is outside of the ranges */
-                        if (dac33->nsample < dac33->nsample_min)
-                                dac33->nsample = dac33->nsample_min;
-                        if (dac33->nsample > dac33->nsample_max)
-                                dac33->nsample = dac33->nsample_max;
-                }
+                        dac33->nsample = period_size *
+                                ((dac33->alarm_threshold / period_size) +
+                                (dac33->alarm_threshold % period_size ?
+                                1 : 0));
+                else if (period_size > nsample_limit)
+                        dac33->nsample = nsample_limit;
+                else
+                        dac33->nsample = period_size;
 
                 dac33->mode1_us_burst = SAMPLES_TO_US(dac33->burst_rate,
                                                       dac33->nsample);
                 dac33->t_stamp1 = 0;
                 dac33->t_stamp2 = 0;
                 break;
         case DAC33_FIFO_MODE7:
-                if (dac33->auto_fifo_config) {
-                        dac33->uthr = UTHR_FROM_PERIOD_SIZE(
-                                        period_size,
-                                        rate,
-                                        dac33->burst_rate) + 9;
-                        if (dac33->uthr > MODE7_UTHR)
-                                dac33->uthr = MODE7_UTHR;
-                        if (dac33->uthr < (MODE7_LTHR + 10))
-                                dac33->uthr = (MODE7_LTHR + 10);
-                }
+                dac33->uthr = UTHR_FROM_PERIOD_SIZE(period_size, rate,
+                                                    dac33->burst_rate) + 9;
+                if (dac33->uthr > (dac33->fifo_size - DAC33_MODE7_MARGIN))
+                        dac33->uthr = dac33->fifo_size - DAC33_MODE7_MARGIN;
+                if (dac33->uthr < (DAC33_MODE7_MARGIN + 10))
+                        dac33->uthr = (DAC33_MODE7_MARGIN + 10);
+
                 dac33->mode7_us_to_lthr =
                                 SAMPLES_TO_US(substream->runtime->rate,
-                                        dac33->uthr - MODE7_LTHR + 1);
+                                        dac33->uthr - DAC33_MODE7_MARGIN + 1);
                 dac33->t_stamp1 = 0;
                 break;
         default:
                 break;
         }
 
 }
 
 static int dac33_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
                              struct snd_soc_dai *dai)
@@ skipping 97 matching lines @@
                         time_delta = t_now - t0;
                         samples_out = time_delta ? US_TO_SAMPLES(
                                                 substream->runtime->rate,
                                                 time_delta) : 0;
 
                         samples_in = dac33->nsample;
                         samples = dac33->alarm_threshold;
                         samples += (samples_in - samples_out);
 
                         if (likely(samples > 0))
-                                delay = samples > DAC33_BUFFER_SIZE_SAMPLES ?
-                                        DAC33_BUFFER_SIZE_SAMPLES : samples;
+                                delay = samples > dac33->fifo_size ?
+                                        dac33->fifo_size : samples;
                         else
                                 delay = 0;
                 }
                 break;
         case DAC33_FIFO_MODE7:
                 spin_lock(&dac33->lock);
                 t0 = dac33->t_stamp1;
                 uthr = dac33->uthr;
                 spin_unlock(&dac33->lock);
                 t_now = ktime_to_us(ktime_get());
@@ skipping 31 matching lines @@
                         * During burst operation
                         */
                         time_delta = time_delta - dac33->mode7_us_to_lthr;
 
                         samples_out = US_TO_SAMPLES(
                                         substream->runtime->rate,
                                         time_delta);
                         samples_in = US_TO_SAMPLES(
                                         dac33->burst_rate,
                                         time_delta);
-                        delay = MODE7_LTHR + samples_in - samples_out;
+                        delay = DAC33_MODE7_MARGIN + samples_in - samples_out;
 
                         if (unlikely(delay > uthr))
                                 delay = uthr;
                 }
                 break;
         default:
                 dev_warn(codec->dev, "Unhandled FIFO mode: %d\n",
                                                         dac33->fifo_mode);
                 break;
         }
@@ skipping 86 matching lines @@
         return 0;
 }
 
 static int dac33_soc_probe(struct snd_soc_codec *codec)
 {
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
         int ret = 0;
 
         codec->control_data = dac33->control_data;
         codec->hw_write = (hw_write_t) i2c_master_send;
-        codec->idle_bias_off = 1;
+        codec->dapm.idle_bias_off = 1;
         dac33->codec = codec;
 
         /* Read the tlv320dac33 ID registers */
         ret = dac33_hard_power(codec, 1);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to power up codec: %d\n", ret);
                 goto err_power;
         }
         ret = dac33_read_id(codec);
         dac33_hard_power(codec, 0);
@@ skipping 23 matching lines @@
                                 return -ENOMEM;
                         }
 
                         INIT_WORK(&dac33->work, dac33_work);
                 }
         }
 
         snd_soc_add_controls(codec, dac33_snd_controls,
                              ARRAY_SIZE(dac33_snd_controls));
         /* Only add the FIFO controls, if we have valid IRQ number */
-        if (dac33->irq >= 0) {
+        if (dac33->irq >= 0)
                 snd_soc_add_controls(codec, dac33_mode_snd_controls,
                                      ARRAY_SIZE(dac33_mode_snd_controls));
-                /* FIFO usage controls only, if autoio config is not selected */
-                if (!dac33->auto_fifo_config)
-                        snd_soc_add_controls(codec, dac33_fifo_snd_controls,
-                                        ARRAY_SIZE(dac33_fifo_snd_controls));
-        }
+
         dac33_add_widgets(codec);
 
 err_power:
         return ret;
 }
 
 static int dac33_soc_remove(struct snd_soc_codec *codec)
 {
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
@@ skipping 28 matching lines @@
         .reg_word_size = sizeof(u8),
         .reg_cache_default = dac33_reg,
         .probe = dac33_soc_probe,
         .remove = dac33_soc_remove,
         .suspend = dac33_soc_suspend,
         .resume = dac33_soc_resume,
 };
 
 #define DAC33_RATES     (SNDRV_PCM_RATE_44100 | \
                          SNDRV_PCM_RATE_48000)
-#define DAC33_FORMATS   SNDRV_PCM_FMTBIT_S16_LE
+#define DAC33_FORMATS   (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
 
 static struct snd_soc_dai_ops dac33_dai_ops = {
         .startup        = dac33_startup,
         .shutdown       = dac33_shutdown,
         .hw_params      = dac33_hw_params,
         .trigger        = dac33_pcm_trigger,
         .delay          = dac33_dai_delay,
         .set_sysclk     = dac33_set_dai_sysclk,
         .set_fmt        = dac33_set_dai_fmt,
 };
@@ skipping 27 matching lines @@
                 return -ENOMEM;
 
         dac33->control_data = client;
         mutex_init(&dac33->mutex);
         spin_lock_init(&dac33->lock);
 
         i2c_set_clientdata(client, dac33);
 
         dac33->power_gpio = pdata->power_gpio;
         dac33->burst_bclkdiv = pdata->burst_bclkdiv;
-        /* Pre calculate the burst rate */
-        dac33->burst_rate = BURST_BASEFREQ_HZ / dac33->burst_bclkdiv / 32;
         dac33->keep_bclk = pdata->keep_bclk;
-        dac33->auto_fifo_config = pdata->auto_fifo_config;
         dac33->mode1_latency = pdata->mode1_latency;
         if (!dac33->mode1_latency)
                 dac33->mode1_latency = 10000; /* 10ms */
         dac33->irq = client->irq;
-        dac33->nsample = NSAMPLE_MAX;
-        dac33->nsample_max = NSAMPLE_MAX;
-        dac33->uthr = MODE7_UTHR;
         /* Disable FIFO use by default */
         dac33->fifo_mode = DAC33_FIFO_BYPASS;
 
         /* Check if the reset GPIO number is valid and request it */
         if (dac33->power_gpio >= 0) {
                 ret = gpio_request(dac33->power_gpio, "tlv320dac33 reset");
                 if (ret < 0) {
                         dev_err(&client->dev,
                                 "Failed to request reset GPIO (%d)\n",
                                 dac33->power_gpio);
@@ skipping 80 matching lines @@
 static void __exit dac33_module_exit(void)
 {
         i2c_del_driver(&tlv320dac33_i2c_driver);
 }
 module_exit(dac33_module_exit);
 
 
 MODULE_DESCRIPTION("ASoC TLV320DAC33 codec driver");
 MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@nokia.com>");
 MODULE_LICENSE("GPL");