Merge branch 'for-2.6.38' of... (2f55eaab) · Commits · e / devices / android_kernel_xiaomi_markw

sound/soc/codecs/Kconfig

+3 −0

Original line number	Diff line number	Diff line
		@@ -167,6 +167,9 @@ config SND_SOC_L3
		config SND_SOC_DA7210
		tristate

		config SND_SOC_DMIC
		tristate

		config SND_SOC_MAX98088
		tristate

sound/soc/codecs/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -14,6 +14,7 @@ snd-soc-cs42l51-objs := cs42l51.o
		snd-soc-cs4270-objs := cs4270.o
		snd-soc-cx20442-objs := cx20442.o
		snd-soc-da7210-objs := da7210.o
		snd-soc-dmic-objs := dmic.o
		snd-soc-l3-objs := l3.o
		snd-soc-max98088-objs := max98088.o
		snd-soc-pcm3008-objs := pcm3008.o
		@@ -92,6 +93,7 @@ obj-$(CONFIG_SND_SOC_CS42L51) += snd-soc-cs42l51.o
		obj-$(CONFIG_SND_SOC_CS4270) += snd-soc-cs4270.o
		obj-$(CONFIG_SND_SOC_CX20442) += snd-soc-cx20442.o
		obj-$(CONFIG_SND_SOC_DA7210) += snd-soc-da7210.o
		obj-$(CONFIG_SND_SOC_DMIC) += snd-soc-dmic.o
		obj-$(CONFIG_SND_SOC_L3) += snd-soc-l3.o
		obj-$(CONFIG_SND_SOC_JZ4740_CODEC) += snd-soc-jz4740-codec.o
		obj-$(CONFIG_SND_SOC_MAX98088) += snd-soc-max98088.o

sound/soc/codecs/dmic.c

0 → 100644

+81 −0

Original line number	Diff line number	Diff line
		/*
		* dmic.c -- SoC audio for Generic Digital MICs
		*
		* Author: Liam Girdwood <lrg@slimlogic.co.uk>
		*
		* This program is free software; you can redistribute it and/or
		* modify it under the terms of the GNU General Public License
		* version 2 as published by the Free Software Foundation.
		*
		* This program is distributed in the hope that it will be useful, but
		* WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		* General Public License for more details.
		*
		* You should have received a copy of the GNU General Public License
		* along with this program; if not, write to the Free Software
		* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
		* 02110-1301 USA
		*
		*/

		#include <linux/platform_device.h>
		#include <linux/slab.h>
		#include <sound/core.h>
		#include <sound/pcm.h>
		#include <sound/soc.h>
		#include <sound/soc-dapm.h>

		static struct snd_soc_dai_driver dmic_dai = {
		.name = "dmic-hifi",
		.capture = {
		.stream_name = "Capture",
		.channels_min = 1,
		.channels_max = 8,
		.rates = SNDRV_PCM_RATE_CONTINUOUS,
		.formats = SNDRV_PCM_FMTBIT_S32_LE
		\| SNDRV_PCM_FMTBIT_S24_LE
		\| SNDRV_PCM_FMTBIT_S16_LE,
		},
		};

		static struct snd_soc_codec_driver soc_dmic = {};

		static int __devinit dmic_dev_probe(struct platform_device *pdev)
		{
		return snd_soc_register_codec(&pdev->dev,
		&soc_dmic, &dmic_dai, 1);
		}

		static int __devexit dmic_dev_remove(struct platform_device *pdev)
		{
		snd_soc_unregister_codec(&pdev->dev);
		return 0;
		}

		MODULE_ALIAS("platform:dmic-codec");

		static struct platform_driver dmic_driver = {
		.driver = {
		.name = "dmic-codec",
		.owner = THIS_MODULE,
		},
		.probe = dmic_dev_probe,
		.remove = __devexit_p(dmic_dev_remove),
		};

		static int __init dmic_init(void)
		{
		return platform_driver_register(&dmic_driver);
		}
		module_init(dmic_init);

		static void __exit dmic_exit(void)
		{
		platform_driver_unregister(&dmic_driver);
		}
		module_exit(dmic_exit);

		MODULE_DESCRIPTION("Generic DMIC driver");
		MODULE_AUTHOR("Liam Girdwood <lrg@slimlogic.co.uk>");
		MODULE_LICENSE("GPL");

sound/soc/codecs/tlv320dac33.c

+108 −161

Original line number	Diff line number	Diff line
		@@ -42,14 +42,15 @@
		#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

		@@ -99,16 +100,11 @@ struct tlv320dac33_priv {
		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 */

		@@ -302,7 +298,6 @@ static void dac33_init_chip(struct snd_soc_codec *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 */
		@@ -325,6 +320,10 @@ static void dac33_init_chip(struct snd_soc_codec *codec)
		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)
		@@ -436,73 +435,6 @@ static int dac33_playback_event(struct snd_soc_dapm_widget *w,
		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)
		{
		@@ -587,13 +519,6 @@ static const struct snd_kcontrol_new dac33_mode_snd_controls[] = {
		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);
		@@ -601,6 +526,25 @@ static const struct snd_kcontrol_new dac33_dapm_abypassl_control =
		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"),
		@@ -617,6 +561,18 @@ static const struct snd_soc_dapm_widget dac33_dapm_widgets[] = {
		SND_SOC_DAPM_SWITCH("Analog Right Bypass", SND_SOC_NOPM, 0, 0,
		&dac33_dapm_abypassr_control),

		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 Amplifier",
		@@ -639,11 +595,22 @@ static const struct snd_soc_dapm_route audio_map[] = {
		{"Output Left Amplifier", NULL, "DACL"},
		{"Output Right Amplifier", NULL, "DACR"},

		{"Output Left Amplifier", NULL, "Analog Left Bypass"},
		{"Output Right Amplifier", 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"},

		{"Output Left Amplifier", NULL, "Left DAC Power"},
		{"Output Right Amplifier", NULL, "Right DAC Power"},
		{"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 Amplifier"},
		@@ -732,7 +699,7 @@ static inline void dac33_prefill_handler(struct tlv320dac33_priv *dac33)
		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);
		@@ -842,6 +809,8 @@ static int dac33_startup(struct snd_pcm_substream *substream,
		/* Stream started, save the substream pointer */
		dac33->substream = substream;

		snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24);

		return 0;
		}

		@@ -853,18 +822,17 @@ static void dac33_shutdown(struct snd_pcm_substream *substream,
		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)) {
		@@ -879,6 +847,12 @@ static int dac33_hw_params(struct snd_pcm_substream *substream,

		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",
		@@ -933,6 +907,9 @@ static int dac33_prepare_chip(struct snd_pcm_substream *substream)
		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);
		@@ -1067,7 +1044,10 @@ static int dac33_prepare_chip(struct snd_pcm_substream *substream)
		dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_C,
		dac33->burst_bclkdiv);
		else
		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:
		@@ -1080,7 +1060,8 @@ static int dac33_prepare_chip(struct snd_pcm_substream *substream)
		* 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;
		@@ -1109,10 +1090,8 @@ static void dac33_calculate_times(struct snd_pcm_substream *substream)
		/* 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,
		@@ -1126,25 +1105,6 @@ static void dac33_calculate_times(struct snd_pcm_substream *substream)
		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;
		/*
		* nSample should not be bigger than alsa buffer minus
		* size of one period to avoid overruns
		*/
		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->mode1_us_burst = SAMPLES_TO_US(dac33->burst_rate,
		dac33->nsample);
		@@ -1152,19 +1112,16 @@ static void dac33_calculate_times(struct snd_pcm_substream *substream)
		dac33->t_stamp2 = 0;
		break;
		case DAC33_FIFO_MODE7:
		if (dac33->auto_fifo_config) {
		dac33->uthr = UTHR_FROM_PERIOD_SIZE(
		period_size,
		rate,
		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);
		}
		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:
		@@ -1282,8 +1239,8 @@ static snd_pcm_sframes_t dac33_dai_delay(
		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;
		}
		@@ -1335,7 +1292,7 @@ static snd_pcm_sframes_t dac33_dai_delay(
		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;
		@@ -1486,14 +1443,10 @@ static int dac33_soc_probe(struct snd_soc_codec *codec)
		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:
		@@ -1542,7 +1495,7 @@ static struct snd_soc_codec_driver soc_codec_dev_tlv320dac33 = {

		#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,
		@@ -1590,17 +1543,11 @@ static int __devinit dac33_i2c_probe(struct i2c_client *client,

		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;

sound/soc/codecs/tpa6130a2.c

+0 −1

Original line number	Diff line number	Diff line
		@@ -339,7 +339,6 @@ EXPORT_SYMBOL_GPL(tpa6130a2_stereo_enable);
		int tpa6130a2_add_controls(struct snd_soc_codec *codec)
		{
		struct tpa6130a2_data *data;
		struct snd_soc_dapm_context *dapm = &codec->dapm;

		if (tpa6130a2_client == NULL)
		return -ENODEV;