Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 9bffb1fb7c22c96d51d4ba06e2e023dd568a5872

Authored by Misael Lopez Cruz 2012-12-14 02:23:05 +0800

Committed by Mark Brown 2012-12-15 22:45:09 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

ASoC: Prevent pop_wait overwrite

pop_wait is used to determine if a deferred playback close
needs to be cancelled when the a PCM is open or if after
the power-down delay expires it needs to run. pop_wait is
associated with the CODEC DAI, so the CODEC DAI must be
unique. This holds true for most CODECs, except for the
dummy CODEC and its DAI.

In DAI links with non-unique dummy CODECs (e.g. front-ends),
pop_wait can be overwritten by another DAI link using also a
dummy CODEC. Failure to cancel a deferred close can cause
mute due to the DAPM STOP event sent in the deferred work.

One scenario where pop_wait is overwritten and causing mute
is below (where hw:0,0 and hw:0,1 are two front-ends with
default pmdown_time = 5 secs):

aplay /dev/urandom -D hw:0,0 -c 2 -r 48000 -f S16_LE -d 1
sleep 1
aplay /dev/urandom -D hw:0,1 -c 2 -r 48000 -f S16_LE -d 3 &
aplay /dev/urandom -D hw:0,0 -c 2 -r 48000 -f S16_LE

Since CODECs may not be unique, pop_wait is moved to the PCM
runtime structure. Creating separate dummy CODECs for each
DAI link can also solve the problem, but at this point it's
only pop_wait variable in the CODEC DAI that has negative
effects by not being unique.

Signed-off-by: Misael Lopez Cruz <misael.lopez@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

Showing 4 changed files with 8 additions and 8 deletions Inline Diff

include/sound/soc-dai.h
include/sound/soc.h
sound/soc/soc-compress.c
sound/soc/soc-pcm.c

include/sound/soc-dai.h

Diff comments View file @ 9bffb1f

 /*
  * linux/sound/soc-dai.h -- ALSA SoC Layer
  *
  * Copyright:	2005-2008 Wolfson Microelectronics. PLC.
  *
  * 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.
  *
  * Digital Audio Interface (DAI) API.
  */
 #ifndef __LINUX_SND_SOC_DAI_H
 #define __LINUX_SND_SOC_DAI_H
 #include <linux/list.h>
 struct snd_pcm_substream;
 struct snd_soc_dapm_widget;
 struct snd_compr_stream;
 /*
  * DAI hardware audio formats.
  *
  * Describes the physical PCM data formating and clocking. Add new formats
  * to the end.
  */
 #define SND_SOC_DAIFMT_I2S		1 /* I2S mode */
 #define SND_SOC_DAIFMT_RIGHT_J		2 /* Right Justified mode */
 #define SND_SOC_DAIFMT_LEFT_J		3 /* Left Justified mode */
 #define SND_SOC_DAIFMT_DSP_A		4 /* L data MSB after FRM LRC */
 #define SND_SOC_DAIFMT_DSP_B		5 /* L data MSB during FRM LRC */
 #define SND_SOC_DAIFMT_AC97		6 /* AC97 */
 #define SND_SOC_DAIFMT_PDM		7 /* Pulse density modulation */
 /* left and right justified also known as MSB and LSB respectively */
 #define SND_SOC_DAIFMT_MSB		SND_SOC_DAIFMT_LEFT_J
 #define SND_SOC_DAIFMT_LSB		SND_SOC_DAIFMT_RIGHT_J
 /*
  * DAI Clock gating.
  *
  * DAI bit clocks can be be gated (disabled) when the DAI is not
  * sending or receiving PCM data in a frame. This can be used to save power.
  */
 #define SND_SOC_DAIFMT_CONT		(1 << 4) /* continuous clock */
 #define SND_SOC_DAIFMT_GATED		(2 << 4) /* clock is gated */
 /*
  * DAI hardware signal inversions.
  *
  * Specifies whether the DAI can also support inverted clocks for the specified
  * format.
  */
 #define SND_SOC_DAIFMT_NB_NF		(1 << 8) /* normal bit clock + frame */
 #define SND_SOC_DAIFMT_NB_IF		(2 << 8) /* normal BCLK + inv FRM */
 #define SND_SOC_DAIFMT_IB_NF		(3 << 8) /* invert BCLK + nor FRM */
 #define SND_SOC_DAIFMT_IB_IF		(4 << 8) /* invert BCLK + FRM */
 /*
  * DAI hardware clock masters.
  *
  * This is wrt the codec, the inverse is true for the interface
  * i.e. if the codec is clk and FRM master then the interface is
  * clk and frame slave.
  */
 #define SND_SOC_DAIFMT_CBM_CFM		(1 << 12) /* codec clk & FRM master */
 #define SND_SOC_DAIFMT_CBS_CFM		(2 << 12) /* codec clk slave & FRM master */
 #define SND_SOC_DAIFMT_CBM_CFS		(3 << 12) /* codec clk master & frame slave */
 #define SND_SOC_DAIFMT_CBS_CFS		(4 << 12) /* codec clk & FRM slave */
 #define SND_SOC_DAIFMT_FORMAT_MASK	0x000f
 #define SND_SOC_DAIFMT_CLOCK_MASK	0x00f0
 #define SND_SOC_DAIFMT_INV_MASK		0x0f00
 #define SND_SOC_DAIFMT_MASTER_MASK	0xf000
 /*
  * Master Clock Directions
  */
 #define SND_SOC_CLOCK_IN		0
 #define SND_SOC_CLOCK_OUT		1
 #define SND_SOC_STD_AC97_FMTS (SNDRV_PCM_FMTBIT_S8 |\
 			       SNDRV_PCM_FMTBIT_S16_LE |\
 			       SNDRV_PCM_FMTBIT_S16_BE |\
 			       SNDRV_PCM_FMTBIT_S20_3LE |\
 			       SNDRV_PCM_FMTBIT_S20_3BE |\
 			       SNDRV_PCM_FMTBIT_S24_3LE |\
 			       SNDRV_PCM_FMTBIT_S24_3BE |\
                                SNDRV_PCM_FMTBIT_S32_LE |\
                                SNDRV_PCM_FMTBIT_S32_BE)
 struct snd_soc_dai_driver;
 struct snd_soc_dai;
 struct snd_ac97_bus_ops;
 /* Digital Audio Interface registration */
 int snd_soc_register_dai(struct device *dev,
 		struct snd_soc_dai_driver *dai_drv);
 void snd_soc_unregister_dai(struct device *dev);
 int snd_soc_register_dais(struct device *dev,
 		struct snd_soc_dai_driver *dai_drv, size_t count);
 void snd_soc_unregister_dais(struct device *dev, size_t count);
 /* Digital Audio Interface clocking API.*/
 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
 	unsigned int freq, int dir);
 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
 	int div_id, int div);
 int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
 	int pll_id, int source, unsigned int freq_in, unsigned int freq_out);
 /* Digital Audio interface formatting */
 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt);
 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
 	unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width);
 int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
 	unsigned int tx_num, unsigned int *tx_slot,
 	unsigned int rx_num, unsigned int *rx_slot);
 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate);
 /* Digital Audio Interface mute */
 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute);
 struct snd_soc_dai_ops {
 	/*
 	 * DAI clocking configuration, all optional.
 	 * Called by soc_card drivers, normally in their hw_params.
 	 */
 	int (*set_sysclk)(struct snd_soc_dai *dai,
 		int clk_id, unsigned int freq, int dir);
 	int (*set_pll)(struct snd_soc_dai *dai, int pll_id, int source,
 		unsigned int freq_in, unsigned int freq_out);
 	int (*set_clkdiv)(struct snd_soc_dai *dai, int div_id, int div);
 	/*
 	 * DAI format configuration
 	 * Called by soc_card drivers, normally in their hw_params.
 	 */
 	int (*set_fmt)(struct snd_soc_dai *dai, unsigned int fmt);
 	int (*set_tdm_slot)(struct snd_soc_dai *dai,
 		unsigned int tx_mask, unsigned int rx_mask,
 		int slots, int slot_width);
 	int (*set_channel_map)(struct snd_soc_dai *dai,
 		unsigned int tx_num, unsigned int *tx_slot,
 		unsigned int rx_num, unsigned int *rx_slot);
 	int (*set_tristate)(struct snd_soc_dai *dai, int tristate);
 	/*
 	 * DAI digital mute - optional.
 	 * Called by soc-core to minimise any pops.
 	 */
 	int (*digital_mute)(struct snd_soc_dai *dai, int mute);
 	/*
 	 * ALSA PCM audio operations - all optional.
 	 * Called by soc-core during audio PCM operations.
 	 */
 	int (*startup)(struct snd_pcm_substream *,
 		struct snd_soc_dai *);
 	void (*shutdown)(struct snd_pcm_substream *,
 		struct snd_soc_dai *);
 	int (*hw_params)(struct snd_pcm_substream *,
 		struct snd_pcm_hw_params *, struct snd_soc_dai *);
 	int (*hw_free)(struct snd_pcm_substream *,
 		struct snd_soc_dai *);
 	int (*prepare)(struct snd_pcm_substream *,
 		struct snd_soc_dai *);
 	int (*trigger)(struct snd_pcm_substream *, int,
 		struct snd_soc_dai *);
 	int (*bespoke_trigger)(struct snd_pcm_substream *, int,
 		struct snd_soc_dai *);
 	/*
 	 * For hardware based FIFO caused delay reporting.
 	 * Optional.
 	 */
 	snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
 		struct snd_soc_dai *);
 };
 /*
  * Digital Audio Interface Driver.
  *
  * Describes the Digital Audio Interface in terms of its ALSA, DAI and AC97
  * operations and capabilities. Codec and platform drivers will register this
  * structure for every DAI they have.
  *
  * This structure covers the clocking, formating and ALSA operations for each
  * interface.
  */
 struct snd_soc_dai_driver {
 	/* DAI description */
 	const char *name;
 	unsigned int id;
 	int ac97_control;
 	unsigned int base;
 	/* DAI driver callbacks */
 	int (*probe)(struct snd_soc_dai *dai);
 	int (*remove)(struct snd_soc_dai *dai);
 	int (*suspend)(struct snd_soc_dai *dai);
 	int (*resume)(struct snd_soc_dai *dai);
 	/* compress dai */
 	bool compress_dai;
 	/* ops */
 	const struct snd_soc_dai_ops *ops;
 	/* DAI capabilities */
 	struct snd_soc_pcm_stream capture;
 	struct snd_soc_pcm_stream playback;
 	unsigned int symmetric_rates:1;
 	/* probe ordering - for components with runtime dependencies */
 	int probe_order;
 	int remove_order;
 };
 /*
  * Digital Audio Interface runtime data.
  *
  * Holds runtime data for a DAI.
  */
 struct snd_soc_dai {
 	const char *name;
 	int id;
 	struct device *dev;
 	void *ac97_pdata;	/* platform_data for the ac97 codec */
 	/* driver ops */
 	struct snd_soc_dai_driver *driver;
 	/* DAI runtime info */
 	unsigned int capture_active:1;		/* stream is in use */
 	unsigned int playback_active:1;		/* stream is in use */
 	unsigned int symmetric_rates:1;
 	struct snd_pcm_runtime *runtime;
 	unsigned int active;
-	unsigned char pop_wait:1;
 	unsigned char probed:1;
 	struct snd_soc_dapm_widget *playback_widget;
 	struct snd_soc_dapm_widget *capture_widget;
 	struct snd_soc_dapm_context dapm;
 	/* DAI DMA data */
 	void *playback_dma_data;
 	void *capture_dma_data;
 	/* Symmetry data - only valid if symmetry is being enforced */
 	unsigned int rate;
 	/* parent platform/codec */
 	struct snd_soc_platform *platform;
 	struct snd_soc_codec *codec;
 	struct snd_soc_card *card;
 	struct list_head list;
 	struct list_head card_list;
 };
 static inline void *snd_soc_dai_get_dma_data(const struct snd_soc_dai *dai,
 					     const struct snd_pcm_substream *ss)
 {
 	return (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
 		dai->playback_dma_data : dai->capture_dma_data;
 }
 static inline void snd_soc_dai_set_dma_data(struct snd_soc_dai *dai,
 					    const struct snd_pcm_substream *ss,
 					    void *data)
 {
 	if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
 		dai->playback_dma_data = data;
 	else
 		dai->capture_dma_data = data;
 }
 static inline void snd_soc_dai_set_drvdata(struct snd_soc_dai *dai,
 		void *data)
 {
 	dev_set_drvdata(dai->dev, data);
 }
 static inline void *snd_soc_dai_get_drvdata(struct snd_soc_dai *dai)
 {
 	return dev_get_drvdata(dai->dev);
 }
 #endif

include/sound/soc.h

Diff comments View file @ 9bffb1f

 /*
  * linux/sound/soc.h -- ALSA SoC Layer
  *
  * Author:		Liam Girdwood
  * Created:		Aug 11th 2005
  * Copyright:	Wolfson Microelectronics. PLC.
  *
  * 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.
  */
 #ifndef __LINUX_SND_SOC_H
 #define __LINUX_SND_SOC_H
 #include <linux/platform_device.h>
 #include <linux/types.h>
 #include <linux/notifier.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/regmap.h>
 #include <linux/log2.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/compress_driver.h>
 #include <sound/control.h>
 #include <sound/ac97_codec.h>
 /*
  * Convenience kcontrol builders
  */
 #define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert) \
 	((unsigned long)&(struct soc_mixer_control) \
 	{.reg = xreg, .rreg = xreg, .shift = shift_left, \
 	.rshift = shift_right, .max = xmax, .platform_max = xmax, \
 	.invert = xinvert})
 #define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) \
 	SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert)
 #define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
 	((unsigned long)&(struct soc_mixer_control) \
 	{.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
 #define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
 	((unsigned long)&(struct soc_mixer_control) \
 	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
 	.max = xmax, .platform_max = xmax, .invert = xinvert})
 #define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
 	((unsigned long)&(struct soc_mixer_control) \
 	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
 	.min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
 #define SOC_SINGLE(xname, reg, shift, max, invert) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
 	.put = snd_soc_put_volsw, \
 	.private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
 #define SOC_SINGLE_RANGE(xname, xreg, xshift, xmin, xmax, xinvert) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 	.info = snd_soc_info_volsw_range, .get = snd_soc_get_volsw_range, \
 	.put = snd_soc_put_volsw_range, \
 	.private_value = (unsigned long)&(struct soc_mixer_control) \
 		{.reg = xreg, .shift = xshift, .min = xmin,\
 		 .max = xmax, .platform_max = xmax, .invert = xinvert} }
 #define SOC_SINGLE_TLV(xname, reg, shift, max, invert, 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 = snd_soc_get_volsw,\
 	.put = snd_soc_put_volsw, \
 	.private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
 #define SOC_SINGLE_SX_TLV(xname, xreg, xshift, xmin, xmax, 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 = snd_soc_get_volsw_sx,\
 	.put = snd_soc_put_volsw_sx, \
 	.private_value = (unsigned long)&(struct soc_mixer_control) \
 		{.reg = xreg, .rreg = xreg, \
 		.shift = xshift, .rshift = xshift, \
 		.max = xmax, .min = xmin} }
 #define SOC_SINGLE_RANGE_TLV(xname, xreg, xshift, xmin, 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_range, \
 	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
 	.private_value = (unsigned long)&(struct soc_mixer_control) \
 		{.reg = xreg, .shift = xshift, .min = xmin,\
 		 .max = xmax, .platform_max = xmax, .invert = xinvert} }
 #define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
 	.put = snd_soc_put_volsw, \
 	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
 					  max, invert) }
 #define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 	.info = snd_soc_info_volsw, \
 	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
 	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 					    xmax, xinvert) }
 #define SOC_DOUBLE_R_RANGE(xname, reg_left, reg_right, xshift, xmin, \
 			   xmax, xinvert)		\
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 	.info = snd_soc_info_volsw_range, \
 	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
 	.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
 					    xshift, xmin, xmax, xinvert) }
 #define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, 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 = snd_soc_get_volsw, \
 	.put = snd_soc_put_volsw, \
 	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
 					  max, invert) }
 #define SOC_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,\
 	.tlv.p = (tlv_array), \
 	.info = snd_soc_info_volsw, \
 	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
 	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 					    xmax, xinvert) }
 #define SOC_DOUBLE_R_RANGE_TLV(xname, reg_left, reg_right, xshift, xmin, \
 			       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_range, \
 	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
 	.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
 					    xshift, xmin, xmax, xinvert) }
 #define SOC_DOUBLE_R_SX_TLV(xname, xreg, xrreg, xshift, xmin, xmax, 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 = snd_soc_get_volsw_sx, \
 	.put = snd_soc_put_volsw_sx, \
 	.private_value = (unsigned long)&(struct soc_mixer_control) \
 		{.reg = xreg, .rreg = xrreg, \
 		.shift = xshift, .rshift = xshift, \
 		.max = xmax, .min = xmin} }
 #define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, 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_s8, .get = snd_soc_get_volsw_s8, \
 	.put    = snd_soc_put_volsw_s8, \
 	.private_value = (unsigned long)&(struct soc_mixer_control) \
 		{.reg = xreg, .min = xmin, .max = xmax, \
 		 .platform_max = xmax} }
 #define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmax, xtexts) \
 {	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
 	.max = xmax, .texts = xtexts, \
 	.mask = xmax ? roundup_pow_of_two(xmax) - 1 : 0}
 #define SOC_ENUM_SINGLE(xreg, xshift, xmax, xtexts) \
 	SOC_ENUM_DOUBLE(xreg, xshift, xshift, xmax, xtexts)
 #define SOC_ENUM_SINGLE_EXT(xmax, xtexts) \
 {	.max = xmax, .texts = xtexts }
 #define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xmax, xtexts, xvalues) \
 {	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
 	.mask = xmask, .max = xmax, .texts = xtexts, .values = xvalues}
 #define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xmax, xtexts, xvalues) \
 	SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xmax, xtexts, xvalues)
 #define SOC_ENUM(xname, xenum) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
 	.info = snd_soc_info_enum_double, \
 	.get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
 	.private_value = (unsigned long)&xenum }
 #define SOC_VALUE_ENUM(xname, xenum) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
 	.info = snd_soc_info_enum_double, \
 	.get = snd_soc_get_value_enum_double, \
 	.put = snd_soc_put_value_enum_double, \
 	.private_value = (unsigned long)&xenum }
 #define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
 	 xhandler_get, xhandler_put) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 	.info = snd_soc_info_volsw, \
 	.get = xhandler_get, .put = xhandler_put, \
 	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
 #define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
 	 xhandler_get, xhandler_put) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
 	.info = snd_soc_info_volsw, \
 	.get = xhandler_get, .put = xhandler_put, \
 	.private_value = \
 		SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert) }
 #define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
 	 xhandler_get, xhandler_put, 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 = xhandler_get, .put = xhandler_put, \
 	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
 #define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
 	 xhandler_get, xhandler_put, 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 = xhandler_get, .put = xhandler_put, \
 	.private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
 					  xmax, xinvert) }
 #define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
 	 xhandler_get, xhandler_put, 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 = xhandler_get, .put = xhandler_put, \
 	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
 					    xmax, xinvert) }
 #define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 	.info = snd_soc_info_bool_ext, \
 	.get = xhandler_get, .put = xhandler_put, \
 	.private_value = xdata }
 #define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 	.info = snd_soc_info_enum_ext, \
 	.get = xhandler_get, .put = xhandler_put, \
 	.private_value = (unsigned long)&xenum }
 #define SND_SOC_BYTES(xname, xbase, xregs)		      \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
 	.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
 	.put = snd_soc_bytes_put, .private_value =	      \
 		((unsigned long)&(struct soc_bytes)           \
 		{.base = xbase, .num_regs = xregs }) }
 #define SND_SOC_BYTES_MASK(xname, xbase, xregs, xmask)	      \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
 	.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
 	.put = snd_soc_bytes_put, .private_value =	      \
 		((unsigned long)&(struct soc_bytes)           \
 		{.base = xbase, .num_regs = xregs,	      \
 		 .mask = xmask }) }
 #define SOC_SINGLE_XR_SX(xname, xregbase, xregcount, xnbits, \
 		xmin, xmax, xinvert) \
 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
 	.info = snd_soc_info_xr_sx, .get = snd_soc_get_xr_sx, \
 	.put = snd_soc_put_xr_sx, \
 	.private_value = (unsigned long)&(struct soc_mreg_control) \
 		{.regbase = xregbase, .regcount = xregcount, .nbits = xnbits, \
 		.invert = xinvert, .min = xmin, .max = xmax} }
 #define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
 	SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
 		snd_soc_get_strobe, snd_soc_put_strobe)
 /*
  * Simplified versions of above macros, declaring a struct and calculating
  * ARRAY_SIZE internally
  */
 #define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
 	struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
 						ARRAY_SIZE(xtexts), xtexts)
 #define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
 	SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
 #define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
 	struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
 #define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
 	struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
 							ARRAY_SIZE(xtexts), xtexts, xvalues)
 #define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
 	SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
 /*
  * Component probe and remove ordering levels for components with runtime
  * dependencies.
  */
 #define SND_SOC_COMP_ORDER_FIRST		-2
 #define SND_SOC_COMP_ORDER_EARLY		-1
 #define SND_SOC_COMP_ORDER_NORMAL		0
 #define SND_SOC_COMP_ORDER_LATE		1
 #define SND_SOC_COMP_ORDER_LAST		2
 /*
  * Bias levels
  *
  * @ON:      Bias is fully on for audio playback and capture operations.
  * @PREPARE: Prepare for audio operations. Called before DAPM switching for
  *           stream start and stop operations.
  * @STANDBY: Low power standby state when no playback/capture operations are
  *           in progress. NOTE: The transition time between STANDBY and ON
  *           should be as fast as possible and no longer than 10ms.
  * @OFF:     Power Off. No restrictions on transition times.
  */
 enum snd_soc_bias_level {
 	SND_SOC_BIAS_OFF = 0,
 	SND_SOC_BIAS_STANDBY = 1,
 	SND_SOC_BIAS_PREPARE = 2,
 	SND_SOC_BIAS_ON = 3,
 };
 struct device_node;
 struct snd_jack;
 struct snd_soc_card;
 struct snd_soc_pcm_stream;
 struct snd_soc_ops;
 struct snd_soc_pcm_runtime;
 struct snd_soc_dai;
 struct snd_soc_dai_driver;
 struct snd_soc_platform;
 struct snd_soc_dai_link;
 struct snd_soc_platform_driver;
 struct snd_soc_codec;
 struct snd_soc_codec_driver;
 struct soc_enum;
 struct snd_soc_jack;
 struct snd_soc_jack_zone;
 struct snd_soc_jack_pin;
 struct snd_soc_cache_ops;
 #include <sound/soc-dapm.h>
 #include <sound/soc-dpcm.h>
 #ifdef CONFIG_GPIOLIB
 struct snd_soc_jack_gpio;
 #endif
 typedef int (*hw_write_t)(void *,const char* ,int);
 extern struct snd_ac97_bus_ops soc_ac97_ops;
 enum snd_soc_control_type {
 	SND_SOC_I2C = 1,
 	SND_SOC_SPI,
 	SND_SOC_REGMAP,
 };
 enum snd_soc_compress_type {
 	SND_SOC_FLAT_COMPRESSION = 1,
 };
 enum snd_soc_pcm_subclass {
 	SND_SOC_PCM_CLASS_PCM	= 0,
 	SND_SOC_PCM_CLASS_BE	= 1,
 };
 enum snd_soc_card_subclass {
 	SND_SOC_CARD_CLASS_INIT		= 0,
 	SND_SOC_CARD_CLASS_RUNTIME	= 1,
 };
 int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
 			     int source, unsigned int freq, int dir);
 int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
 			  unsigned int freq_in, unsigned int freq_out);
 int snd_soc_register_card(struct snd_soc_card *card);
 int snd_soc_unregister_card(struct snd_soc_card *card);
 int snd_soc_suspend(struct device *dev);
 int snd_soc_resume(struct device *dev);
 int snd_soc_poweroff(struct device *dev);
 int snd_soc_register_platform(struct device *dev,
 		struct snd_soc_platform_driver *platform_drv);
 void snd_soc_unregister_platform(struct device *dev);
 int snd_soc_register_codec(struct device *dev,
 		const struct snd_soc_codec_driver *codec_drv,
 		struct snd_soc_dai_driver *dai_drv, int num_dai);
 void snd_soc_unregister_codec(struct device *dev);
 int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
 				    unsigned int reg);
 int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
 				    unsigned int reg);
 int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
 				    unsigned int reg);
 int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
 			       int addr_bits, int data_bits,
 			       enum snd_soc_control_type control);
 int snd_soc_cache_sync(struct snd_soc_codec *codec);
 int snd_soc_cache_init(struct snd_soc_codec *codec);
 int snd_soc_cache_exit(struct snd_soc_codec *codec);
 int snd_soc_cache_write(struct snd_soc_codec *codec,
 			unsigned int reg, unsigned int value);
 int snd_soc_cache_read(struct snd_soc_codec *codec,
 		       unsigned int reg, unsigned int *value);
 int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
 				      unsigned int reg);
 int snd_soc_default_readable_register(struct snd_soc_codec *codec,
 				      unsigned int reg);
 int snd_soc_default_writable_register(struct snd_soc_codec *codec,
 				      unsigned int reg);
 int snd_soc_platform_read(struct snd_soc_platform *platform,
 					unsigned int reg);
 int snd_soc_platform_write(struct snd_soc_platform *platform,
 					unsigned int reg, unsigned int val);
 int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
 int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
 struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
 		const char *dai_link, int stream);
 struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
 		const char *dai_link);
 /* Utility functions to get clock rates from various things */
 int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
 int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
 int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
 int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
 /* set runtime hw params */
 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
 	const struct snd_pcm_hardware *hw);
 int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
 		int cmd, struct snd_soc_platform *platform);
 /* Jack reporting */
 int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
 		     struct snd_soc_jack *jack);
 void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
 int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
 			  struct snd_soc_jack_pin *pins);
 void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
 				    struct notifier_block *nb);
 void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
 				      struct notifier_block *nb);
 int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
 			  struct snd_soc_jack_zone *zones);
 int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
 #ifdef CONFIG_GPIOLIB
 int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
 			struct snd_soc_jack_gpio *gpios);
 void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
 			struct snd_soc_jack_gpio *gpios);
 #endif
 /* codec register bit access */
 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
 				unsigned int mask, unsigned int value);
 int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
 			       unsigned short reg, unsigned int mask,
 			       unsigned int value);
 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
 				unsigned int mask, unsigned int value);
 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
 	struct snd_ac97_bus_ops *ops, int num);
 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec);
 /*
  *Controls
  */
 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
 				  void *data, const char *long_name,
 				  const char *prefix);
 int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
 	const struct snd_kcontrol_new *controls, int num_controls);
 int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
 	const struct snd_kcontrol_new *controls, int num_controls);
 int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
 	const struct snd_kcontrol_new *controls, int num_controls);
 int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
 	const struct snd_kcontrol_new *controls, int num_controls);
 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
 #define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 #define snd_soc_get_volsw_2r snd_soc_get_volsw
 #define snd_soc_put_volsw_2r snd_soc_put_volsw
 int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
 int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_limit_volume(struct snd_soc_codec *codec,
 	const char *name, int max);
 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
 		       struct snd_ctl_elem_info *uinfo);
 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
 		      struct snd_ctl_elem_value *ucontrol);
 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
 		      struct snd_ctl_elem_value *ucontrol);
 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_info *uinfo);
 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol);
 /**
  * struct snd_soc_reg_access - Describes whether a given register is
  * readable, writable or volatile.
  *
  * @reg: the register number
  * @read: whether this register is readable
  * @write: whether this register is writable
  * @vol: whether this register is volatile
  */
 struct snd_soc_reg_access {
 	u16 reg;
 	u16 read;
 	u16 write;
 	u16 vol;
 };
 /**
  * struct snd_soc_jack_pin - Describes a pin to update based on jack detection
  *
  * @pin:    name of the pin to update
  * @mask:   bits to check for in reported jack status
  * @invert: if non-zero then pin is enabled when status is not reported
  */
 struct snd_soc_jack_pin {
 	struct list_head list;
 	const char *pin;
 	int mask;
 	bool invert;
 };
 /**
  * struct snd_soc_jack_zone - Describes voltage zones of jack detection
  *
  * @min_mv: start voltage in mv
  * @max_mv: end voltage in mv
  * @jack_type: type of jack that is expected for this voltage
  * @debounce_time: debounce_time for jack, codec driver should wait for this
  *		duration before reading the adc for voltages
  * @:list: list container
  */
 struct snd_soc_jack_zone {
 	unsigned int min_mv;
 	unsigned int max_mv;
 	unsigned int jack_type;
 	unsigned int debounce_time;
 	struct list_head list;
 };
 /**
  * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
  *
  * @gpio:         gpio number
  * @name:         gpio name
  * @report:       value to report when jack detected
  * @invert:       report presence in low state
  * @debouce_time: debouce time in ms
  * @wake:	  enable as wake source
  * @jack_status_check: callback function which overrides the detection
  *		       to provide more complex checks (eg, reading an
  *		       ADC).
  */
 #ifdef CONFIG_GPIOLIB
 struct snd_soc_jack_gpio {
 	unsigned int gpio;
 	const char *name;
 	int report;
 	int invert;
 	int debounce_time;
 	bool wake;
 	struct snd_soc_jack *jack;
 	struct delayed_work work;
 	int (*jack_status_check)(void);
 };
 #endif
 struct snd_soc_jack {
 	struct mutex mutex;
 	struct snd_jack *jack;
 	struct snd_soc_codec *codec;
 	struct list_head pins;
 	int status;
 	struct blocking_notifier_head notifier;
 	struct list_head jack_zones;
 };
 /* SoC PCM stream information */
 struct snd_soc_pcm_stream {
 	const char *stream_name;
 	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
 	unsigned int rates;		/* SNDRV_PCM_RATE_* */
 	unsigned int rate_min;		/* min rate */
 	unsigned int rate_max;		/* max rate */
 	unsigned int channels_min;	/* min channels */
 	unsigned int channels_max;	/* max channels */
 	unsigned int sig_bits;		/* number of bits of content */
 };
 /* SoC audio ops */
 struct snd_soc_ops {
 	int (*startup)(struct snd_pcm_substream *);
 	void (*shutdown)(struct snd_pcm_substream *);
 	int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
 	int (*hw_free)(struct snd_pcm_substream *);
 	int (*prepare)(struct snd_pcm_substream *);
 	int (*trigger)(struct snd_pcm_substream *, int);
 };
 struct snd_soc_compr_ops {
 	int (*startup)(struct snd_compr_stream *);
 	void (*shutdown)(struct snd_compr_stream *);
 	int (*set_params)(struct snd_compr_stream *);
 	int (*trigger)(struct snd_compr_stream *);
 };
 /* SoC cache ops */
 struct snd_soc_cache_ops {
 	const char *name;
 	enum snd_soc_compress_type id;
 	int (*init)(struct snd_soc_codec *codec);
 	int (*exit)(struct snd_soc_codec *codec);
 	int (*read)(struct snd_soc_codec *codec, unsigned int reg,
 		unsigned int *value);
 	int (*write)(struct snd_soc_codec *codec, unsigned int reg,
 		unsigned int value);
 	int (*sync)(struct snd_soc_codec *codec);
 };
 /* SoC Audio Codec device */
 struct snd_soc_codec {
 	const char *name;
 	const char *name_prefix;
 	int id;
 	struct device *dev;
 	const struct snd_soc_codec_driver *driver;
 	struct mutex mutex;
 	struct snd_soc_card *card;
 	struct list_head list;
 	struct list_head card_list;
 	int num_dai;
 	enum snd_soc_compress_type compress_type;
 	size_t reg_size;	/* reg_cache_size * reg_word_size */
 	int (*volatile_register)(struct snd_soc_codec *, unsigned int);
 	int (*readable_register)(struct snd_soc_codec *, unsigned int);
 	int (*writable_register)(struct snd_soc_codec *, unsigned int);
 	/* runtime */
 	struct snd_ac97 *ac97;  /* for ad-hoc ac97 devices */
 	unsigned int active;
 	unsigned int cache_bypass:1; /* Suppress access to the cache */
 	unsigned int suspended:1; /* Codec is in suspend PM state */
 	unsigned int probed:1; /* Codec has been probed */
 	unsigned int ac97_registered:1; /* Codec has been AC97 registered */
 	unsigned int ac97_created:1; /* Codec has been created by SoC */
 	unsigned int sysfs_registered:1; /* codec has been sysfs registered */
 	unsigned int cache_init:1; /* codec cache has been initialized */
 	unsigned int using_regmap:1; /* using regmap access */
 	u32 cache_only;  /* Suppress writes to hardware */
 	u32 cache_sync; /* Cache needs to be synced to hardware */
 	/* codec IO */
 	void *control_data; /* codec control (i2c/3wire) data */
 	enum snd_soc_control_type control_type;
 	hw_write_t hw_write;
 	unsigned int (*hw_read)(struct snd_soc_codec *, unsigned int);
 	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
 	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
 	int (*bulk_write_raw)(struct snd_soc_codec *, unsigned int, const void *, size_t);
 	void *reg_cache;
 	const void *reg_def_copy;
 	const struct snd_soc_cache_ops *cache_ops;
 	struct mutex cache_rw_mutex;
 	int val_bytes;
 	/* dapm */
 	struct snd_soc_dapm_context dapm;
 	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *debugfs_codec_root;
 	struct dentry *debugfs_reg;
 	struct dentry *debugfs_dapm;
 #endif
 };
 /* codec driver */
 struct snd_soc_codec_driver {
 	/* driver ops */
 	int (*probe)(struct snd_soc_codec *);
 	int (*remove)(struct snd_soc_codec *);
 	int (*suspend)(struct snd_soc_codec *);
 	int (*resume)(struct snd_soc_codec *);
 	/* Default control and setup, added after probe() is run */
 	const struct snd_kcontrol_new *controls;
 	int num_controls;
 	const struct snd_soc_dapm_widget *dapm_widgets;
 	int num_dapm_widgets;
 	const struct snd_soc_dapm_route *dapm_routes;
 	int num_dapm_routes;
 	/* codec wide operations */
 	int (*set_sysclk)(struct snd_soc_codec *codec,
 			  int clk_id, int source, unsigned int freq, int dir);
 	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
 		unsigned int freq_in, unsigned int freq_out);
 	/* codec IO */
 	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
 	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
 	int (*display_register)(struct snd_soc_codec *, char *,
 				size_t, unsigned int);
 	int (*volatile_register)(struct snd_soc_codec *, unsigned int);
 	int (*readable_register)(struct snd_soc_codec *, unsigned int);
 	int (*writable_register)(struct snd_soc_codec *, unsigned int);
 	unsigned int reg_cache_size;
 	short reg_cache_step;
 	short reg_word_size;
 	const void *reg_cache_default;
 	short reg_access_size;
 	const struct snd_soc_reg_access *reg_access_default;
 	enum snd_soc_compress_type compress_type;
 	/* codec bias level */
 	int (*set_bias_level)(struct snd_soc_codec *,
 			      enum snd_soc_bias_level level);
 	bool idle_bias_off;
 	void (*seq_notifier)(struct snd_soc_dapm_context *,
 			     enum snd_soc_dapm_type, int);
 	/* codec stream completion event */
 	int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
 	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
 	/* probe ordering - for components with runtime dependencies */
 	int probe_order;
 	int remove_order;
 };
 /* SoC platform interface */
 struct snd_soc_platform_driver {
 	int (*probe)(struct snd_soc_platform *);
 	int (*remove)(struct snd_soc_platform *);
 	int (*suspend)(struct snd_soc_dai *dai);
 	int (*resume)(struct snd_soc_dai *dai);
 	/* pcm creation and destruction */
 	int (*pcm_new)(struct snd_soc_pcm_runtime *);
 	void (*pcm_free)(struct snd_pcm *);
 	/* Default control and setup, added after probe() is run */
 	const struct snd_kcontrol_new *controls;
 	int num_controls;
 	const struct snd_soc_dapm_widget *dapm_widgets;
 	int num_dapm_widgets;
 	const struct snd_soc_dapm_route *dapm_routes;
 	int num_dapm_routes;
 	/*
 	 * For platform caused delay reporting.
 	 * Optional.
 	 */
 	snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
 		struct snd_soc_dai *);
 	/* platform stream pcm ops */
 	struct snd_pcm_ops *ops;
 	/* platform stream compress ops */
 	struct snd_compr_ops *compr_ops;
 	/* platform stream completion event */
 	int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
 	/* probe ordering - for components with runtime dependencies */
 	int probe_order;
 	int remove_order;
 	/* platform IO - used for platform DAPM */
 	unsigned int (*read)(struct snd_soc_platform *, unsigned int);
 	int (*write)(struct snd_soc_platform *, unsigned int, unsigned int);
 	int (*bespoke_trigger)(struct snd_pcm_substream *, int);
 };
 struct snd_soc_platform {
 	const char *name;
 	int id;
 	struct device *dev;
 	struct snd_soc_platform_driver *driver;
 	struct mutex mutex;
 	unsigned int suspended:1; /* platform is suspended */
 	unsigned int probed:1;
 	struct snd_soc_card *card;
 	struct list_head list;
 	struct list_head card_list;
 	struct snd_soc_dapm_context dapm;
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *debugfs_platform_root;
 	struct dentry *debugfs_dapm;
 #endif
 };
 struct snd_soc_dai_link {
 	/* config - must be set by machine driver */
 	const char *name;			/* Codec name */
 	const char *stream_name;		/* Stream name */
 	/*
 	 * You MAY specify the link's CPU-side device, either by device name,
 	 * or by DT/OF node, but not both. If this information is omitted,
 	 * the CPU-side DAI is matched using .cpu_dai_name only, which hence
 	 * must be globally unique. These fields are currently typically used
 	 * only for codec to codec links, or systems using device tree.
 	 */
 	const char *cpu_name;
 	const struct device_node *cpu_of_node;
 	/*
 	 * You MAY specify the DAI name of the CPU DAI. If this information is
 	 * omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
 	 * only, which only works well when that device exposes a single DAI.
 	 */
 	const char *cpu_dai_name;
 	/*
 	 * You MUST specify the link's codec, either by device name, or by
 	 * DT/OF node, but not both.
 	 */
 	const char *codec_name;
 	const struct device_node *codec_of_node;
 	/* You MUST specify the DAI name within the codec */
 	const char *codec_dai_name;
 	/*
 	 * You MAY specify the link's platform/PCM/DMA driver, either by
 	 * device name, or by DT/OF node, but not both. Some forms of link
 	 * do not need a platform.
 	 */
 	const char *platform_name;
 	const struct device_node *platform_of_node;
 	int be_id;	/* optional ID for machine driver BE identification */
 	const struct snd_soc_pcm_stream *params;
 	unsigned int dai_fmt;           /* format to set on init */
 	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
 	/* Keep DAI active over suspend */
 	unsigned int ignore_suspend:1;
 	/* Symmetry requirements */
 	unsigned int symmetric_rates:1;
 	/* Do not create a PCM for this DAI link (Backend link) */
 	unsigned int no_pcm:1;
 	/* This DAI link can route to other DAI links at runtime (Frontend)*/
 	unsigned int dynamic:1;
 	/* pmdown_time is ignored at stop */
 	unsigned int ignore_pmdown_time:1;
 	/* codec/machine specific init - e.g. add machine controls */
 	int (*init)(struct snd_soc_pcm_runtime *rtd);
 	/* optional hw_params re-writing for BE and FE sync */
 	int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
 			struct snd_pcm_hw_params *params);
 	/* machine stream operations */
 	struct snd_soc_ops *ops;
 	struct snd_soc_compr_ops *compr_ops;
 };
 struct snd_soc_codec_conf {
 	const char *dev_name;
 	/*
 	 * optional map of kcontrol, widget and path name prefixes that are
 	 * associated per device
 	 */
 	const char *name_prefix;
 	/*
 	 * set this to the desired compression type if you want to
 	 * override the one supplied in codec->driver->compress_type
 	 */
 	enum snd_soc_compress_type compress_type;
 };
 struct snd_soc_aux_dev {
 	const char *name;		/* Codec name */
 	const char *codec_name;		/* for multi-codec */
 	/* codec/machine specific init - e.g. add machine controls */
 	int (*init)(struct snd_soc_dapm_context *dapm);
 };
 /* SoC card */
 struct snd_soc_card {
 	const char *name;
 	const char *long_name;
 	const char *driver_name;
 	struct device *dev;
 	struct snd_card *snd_card;
 	struct module *owner;
 	struct list_head list;
 	struct mutex mutex;
 	struct mutex dapm_mutex;
 	bool instantiated;
 	int (*probe)(struct snd_soc_card *card);
 	int (*late_probe)(struct snd_soc_card *card);
 	int (*remove)(struct snd_soc_card *card);
 	/* the pre and post PM functions are used to do any PM work before and
 	 * after the codec and DAI's do any PM work. */
 	int (*suspend_pre)(struct snd_soc_card *card);
 	int (*suspend_post)(struct snd_soc_card *card);
 	int (*resume_pre)(struct snd_soc_card *card);
 	int (*resume_post)(struct snd_soc_card *card);
 	/* callbacks */
 	int (*set_bias_level)(struct snd_soc_card *,
 			      struct snd_soc_dapm_context *dapm,
 			      enum snd_soc_bias_level level);
 	int (*set_bias_level_post)(struct snd_soc_card *,
 				   struct snd_soc_dapm_context *dapm,
 				   enum snd_soc_bias_level level);
 	long pmdown_time;
 	/* CPU <--> Codec DAI links  */
 	struct snd_soc_dai_link *dai_link;
 	int num_links;
 	struct snd_soc_pcm_runtime *rtd;
 	int num_rtd;
 	/* optional codec specific configuration */
 	struct snd_soc_codec_conf *codec_conf;
 	int num_configs;
 	/*
 	 * optional auxiliary devices such as amplifiers or codecs with DAI
 	 * link unused
 	 */
 	struct snd_soc_aux_dev *aux_dev;
 	int num_aux_devs;
 	struct snd_soc_pcm_runtime *rtd_aux;
 	int num_aux_rtd;
 	const struct snd_kcontrol_new *controls;
 	int num_controls;
 	/*
 	 * Card-specific routes and widgets.
 	 */
 	const struct snd_soc_dapm_widget *dapm_widgets;
 	int num_dapm_widgets;
 	const struct snd_soc_dapm_route *dapm_routes;
 	int num_dapm_routes;
 	bool fully_routed;
 	struct work_struct deferred_resume_work;
 	/* lists of probed devices belonging to this card */
 	struct list_head codec_dev_list;
 	struct list_head platform_dev_list;
 	struct list_head dai_dev_list;
 	struct list_head widgets;
 	struct list_head paths;
 	struct list_head dapm_list;
 	struct list_head dapm_dirty;
 	/* Generic DAPM context for the card */
 	struct snd_soc_dapm_context dapm;
 	struct snd_soc_dapm_stats dapm_stats;
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *debugfs_card_root;
 	struct dentry *debugfs_pop_time;
 #endif
 	u32 pop_time;
 	void *drvdata;
 };
 /* SoC machine DAI configuration, glues a codec and cpu DAI together */
 struct snd_soc_pcm_runtime {
 	struct device *dev;
 	struct snd_soc_card *card;
 	struct snd_soc_dai_link *dai_link;
 	struct mutex pcm_mutex;
 	enum snd_soc_pcm_subclass pcm_subclass;
 	struct snd_pcm_ops ops;
 	unsigned int dev_registered:1;
 	/* Dynamic PCM BE runtime data */
 	struct snd_soc_dpcm_runtime dpcm[2];
 	long pmdown_time;
+	unsigned char pop_wait:1;
 	/* runtime devices */
 	struct snd_pcm *pcm;
 	struct snd_compr *compr;
 	struct snd_soc_codec *codec;
 	struct snd_soc_platform *platform;
 	struct snd_soc_dai *codec_dai;
 	struct snd_soc_dai *cpu_dai;
 	struct delayed_work delayed_work;
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *debugfs_dpcm_root;
 	struct dentry *debugfs_dpcm_state;
 #endif
 };
 /* mixer control */
 struct soc_mixer_control {
 	int min, max, platform_max;
 	unsigned int reg, rreg, shift, rshift, invert;
 };
 struct soc_bytes {
 	int base;
 	int num_regs;
 	u32 mask;
 };
 /* multi register control */
 struct soc_mreg_control {
 	long min, max;
 	unsigned int regbase, regcount, nbits, invert;
 };
 /* enumerated kcontrol */
 struct soc_enum {
 	unsigned short reg;
 	unsigned short reg2;
 	unsigned char shift_l;
 	unsigned char shift_r;
 	unsigned int max;
 	unsigned int mask;
 	const char * const *texts;
 	const unsigned int *values;
 	void *dapm;
 };
 /* codec IO */
 unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
 unsigned int snd_soc_write(struct snd_soc_codec *codec,
 			   unsigned int reg, unsigned int val);
 unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
 				    unsigned int reg, const void *data, size_t len);
 /* device driver data */
 static inline void snd_soc_card_set_drvdata(struct snd_soc_card *card,
 		void *data)
 {
 	card->drvdata = data;
 }
 static inline void *snd_soc_card_get_drvdata(struct snd_soc_card *card)
 {
 	return card->drvdata;
 }
 static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
 		void *data)
 {
 	dev_set_drvdata(codec->dev, data);
 }
 static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
 {
 	return dev_get_drvdata(codec->dev);
 }
 static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
 		void *data)
 {
 	dev_set_drvdata(platform->dev, data);
 }
 static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
 {
 	return dev_get_drvdata(platform->dev);
 }
 static inline void snd_soc_pcm_set_drvdata(struct snd_soc_pcm_runtime *rtd,
 		void *data)
 {
 	dev_set_drvdata(rtd->dev, data);
 }
 static inline void *snd_soc_pcm_get_drvdata(struct snd_soc_pcm_runtime *rtd)
 {
 	return dev_get_drvdata(rtd->dev);
 }
 static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
 {
 	INIT_LIST_HEAD(&card->dai_dev_list);
 	INIT_LIST_HEAD(&card->codec_dev_list);
 	INIT_LIST_HEAD(&card->platform_dev_list);
 	INIT_LIST_HEAD(&card->widgets);
 	INIT_LIST_HEAD(&card->paths);
 	INIT_LIST_HEAD(&card->dapm_list);
 }
 static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
 {
 	if (mc->reg == mc->rreg && mc->shift == mc->rshift)
 		return 0;
 	/*
 	 * mc->reg == mc->rreg && mc->shift != mc->rshift, or
 	 * mc->reg != mc->rreg means that the control is
 	 * stereo (bits in one register or in two registers)
 	 */
 	return 1;
 }
 int snd_soc_util_init(void);
 void snd_soc_util_exit(void);
 int snd_soc_of_parse_card_name(struct snd_soc_card *card,
 			       const char *propname);
 int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
 				   const char *propname);
 #include <sound/soc-dai.h>
 #ifdef CONFIG_DEBUG_FS
 extern struct dentry *snd_soc_debugfs_root;
 #endif
 extern const struct dev_pm_ops snd_soc_pm_ops;
 #endif

sound/soc/soc-compress.c

Diff comments View file @ 9bffb1f

1	/*	1	/*
2	* soc-compress.c -- ALSA SoC Compress	2	* soc-compress.c -- ALSA SoC Compress
3	*	3	*
4	* Copyright (C) 2012 Intel Corp.	4	* Copyright (C) 2012 Intel Corp.
5	*	5	*
6	* Authors: Namarta Kohli <namartax.kohli@intel.com>	6	* Authors: Namarta Kohli <namartax.kohli@intel.com>
7	* Ramesh Babu K V <ramesh.babu@linux.intel.com>	7	* Ramesh Babu K V <ramesh.babu@linux.intel.com>
8	* Vinod Koul <vinod.koul@linux.intel.com>	8	* Vinod Koul <vinod.koul@linux.intel.com>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify it	10	* This program is free software; you can redistribute it and/or modify it
11	* under the terms of the GNU General Public License as published by the	11	* under the terms of the GNU General Public License as published by the
12	* Free Software Foundation; either version 2 of the License, or (at your	12	* Free Software Foundation; either version 2 of the License, or (at your
13	* option) any later version.	13	* option) any later version.
14	*	14	*
15	*/	15	*/
16		16
17	#include <linux/kernel.h>	17	#include <linux/kernel.h>
18	#include <linux/init.h>	18	#include <linux/init.h>
19	#include <linux/delay.h>	19	#include <linux/delay.h>
20	#include <linux/slab.h>	20	#include <linux/slab.h>
21	#include <linux/workqueue.h>	21	#include <linux/workqueue.h>
22	#include <sound/core.h>	22	#include <sound/core.h>
23	#include <sound/compress_params.h>	23	#include <sound/compress_params.h>
24	#include <sound/compress_driver.h>	24	#include <sound/compress_driver.h>
25	#include <sound/soc.h>	25	#include <sound/soc.h>
26	#include <sound/initval.h>	26	#include <sound/initval.h>
27		27
28	static int soc_compr_open(struct snd_compr_stream *cstream)	28	static int soc_compr_open(struct snd_compr_stream *cstream)
29	{	29	{
30	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	30	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
31	struct snd_soc_platform *platform = rtd->platform;	31	struct snd_soc_platform *platform = rtd->platform;
32	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;	32	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
33	struct snd_soc_dai *codec_dai = rtd->codec_dai;	33	struct snd_soc_dai *codec_dai = rtd->codec_dai;
34	int ret = 0;	34	int ret = 0;
35		35
36	if (platform->driver->compr_ops && platform->driver->compr_ops->open) {	36	if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
37	ret = platform->driver->compr_ops->open(cstream);	37	ret = platform->driver->compr_ops->open(cstream);
38	if (ret < 0) {	38	if (ret < 0) {
39	pr_err("compress asoc: can't open platform %s\n", platform->name);	39	pr_err("compress asoc: can't open platform %s\n", platform->name);
40	goto out;	40	goto out;
41	}	41	}
42	}	42	}
43		43
44	if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {	44	if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
45	ret = rtd->dai_link->compr_ops->startup(cstream);	45	ret = rtd->dai_link->compr_ops->startup(cstream);
46	if (ret < 0) {	46	if (ret < 0) {
47	pr_err("compress asoc: %s startup failed\n", rtd->dai_link->name);	47	pr_err("compress asoc: %s startup failed\n", rtd->dai_link->name);
48	goto machine_err;	48	goto machine_err;
49	}	49	}
50	}	50	}
51		51
52	if (cstream->direction == SND_COMPRESS_PLAYBACK) {	52	if (cstream->direction == SND_COMPRESS_PLAYBACK) {
53	cpu_dai->playback_active++;	53	cpu_dai->playback_active++;
54	codec_dai->playback_active++;	54	codec_dai->playback_active++;
55	} else {	55	} else {
56	cpu_dai->capture_active++;	56	cpu_dai->capture_active++;
57	codec_dai->capture_active++;	57	codec_dai->capture_active++;
58	}	58	}
59		59
60	cpu_dai->active++;	60	cpu_dai->active++;
61	codec_dai->active++;	61	codec_dai->active++;
62	rtd->codec->active++;	62	rtd->codec->active++;
63		63
64	return 0;	64	return 0;
65		65
66	machine_err:	66	machine_err:
67	if (platform->driver->compr_ops && platform->driver->compr_ops->free)	67	if (platform->driver->compr_ops && platform->driver->compr_ops->free)
68	platform->driver->compr_ops->free(cstream);	68	platform->driver->compr_ops->free(cstream);
69	out:	69	out:
70	return ret;	70	return ret;
71	}	71	}
72		72
73	static int soc_compr_free(struct snd_compr_stream *cstream)	73	static int soc_compr_free(struct snd_compr_stream *cstream)
74	{	74	{
75	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	75	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
76	struct snd_soc_platform *platform = rtd->platform;	76	struct snd_soc_platform *platform = rtd->platform;
77	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;	77	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
78	struct snd_soc_dai *codec_dai = rtd->codec_dai;	78	struct snd_soc_dai *codec_dai = rtd->codec_dai;
79	struct snd_soc_codec *codec = rtd->codec;	79	struct snd_soc_codec *codec = rtd->codec;
80		80
81	if (cstream->direction == SND_COMPRESS_PLAYBACK) {	81	if (cstream->direction == SND_COMPRESS_PLAYBACK) {
82	cpu_dai->playback_active--;	82	cpu_dai->playback_active--;
83	codec_dai->playback_active--;	83	codec_dai->playback_active--;
84	} else {	84	} else {
85	cpu_dai->capture_active--;	85	cpu_dai->capture_active--;
86	codec_dai->capture_active--;	86	codec_dai->capture_active--;
87	}	87	}
88		88
89	snd_soc_dai_digital_mute(codec_dai, 1);	89	snd_soc_dai_digital_mute(codec_dai, 1);
90		90
91	cpu_dai->active--;	91	cpu_dai->active--;
92	codec_dai->active--;	92	codec_dai->active--;
93	codec->active--;	93	codec->active--;
94		94
95	if (!cpu_dai->active)	95	if (!cpu_dai->active)
96	cpu_dai->rate = 0;	96	cpu_dai->rate = 0;
97		97
98	if (!codec_dai->active)	98	if (!codec_dai->active)
99	codec_dai->rate = 0;	99	codec_dai->rate = 0;
100		100
101		101
102	if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)	102	if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
103	rtd->dai_link->compr_ops->shutdown(cstream);	103	rtd->dai_link->compr_ops->shutdown(cstream);
104		104
105	if (platform->driver->compr_ops && platform->driver->compr_ops->free)	105	if (platform->driver->compr_ops && platform->driver->compr_ops->free)
106	platform->driver->compr_ops->free(cstream);	106	platform->driver->compr_ops->free(cstream);
107	cpu_dai->runtime = NULL;	107	cpu_dai->runtime = NULL;
108		108
109	if (cstream->direction == SND_COMPRESS_PLAYBACK) {	109	if (cstream->direction == SND_COMPRESS_PLAYBACK) {
110	if (!rtd->pmdown_time \|\| codec->ignore_pmdown_time \|\|	110	if (!rtd->pmdown_time \|\| codec->ignore_pmdown_time \|\|
111	rtd->dai_link->ignore_pmdown_time) {	111	rtd->dai_link->ignore_pmdown_time) {
112	snd_soc_dapm_stream_event(rtd,	112	snd_soc_dapm_stream_event(rtd,
113	SNDRV_PCM_STREAM_PLAYBACK,	113	SNDRV_PCM_STREAM_PLAYBACK,
114	SND_SOC_DAPM_STREAM_STOP);	114	SND_SOC_DAPM_STREAM_STOP);
115	} else	115	} else
116	codec_dai->pop_wait = 1;	116	rtd->pop_wait = 1;
117	schedule_delayed_work(&rtd->delayed_work,	117	schedule_delayed_work(&rtd->delayed_work,
118	msecs_to_jiffies(rtd->pmdown_time));	118	msecs_to_jiffies(rtd->pmdown_time));
119	} else {	119	} else {
120	/* capture streams can be powered down now */	120	/* capture streams can be powered down now */
121	snd_soc_dapm_stream_event(rtd,	121	snd_soc_dapm_stream_event(rtd,
122	SNDRV_PCM_STREAM_CAPTURE,	122	SNDRV_PCM_STREAM_CAPTURE,
123	SND_SOC_DAPM_STREAM_STOP);	123	SND_SOC_DAPM_STREAM_STOP);
124	}	124	}
125		125
126	return 0;	126	return 0;
127	}	127	}
128		128
129	static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)	129	static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
130	{	130	{
131		131
132	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	132	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
133	struct snd_soc_platform *platform = rtd->platform;	133	struct snd_soc_platform *platform = rtd->platform;
134	struct snd_soc_dai *codec_dai = rtd->codec_dai;	134	struct snd_soc_dai *codec_dai = rtd->codec_dai;
135	int ret = 0;	135	int ret = 0;
136		136
137	if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {	137	if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
138	ret = platform->driver->compr_ops->trigger(cstream, cmd);	138	ret = platform->driver->compr_ops->trigger(cstream, cmd);
139	if (ret < 0)	139	if (ret < 0)
140	return ret;	140	return ret;
141	}	141	}
142		142
143	if (cmd == SNDRV_PCM_TRIGGER_START)	143	if (cmd == SNDRV_PCM_TRIGGER_START)
144	snd_soc_dai_digital_mute(codec_dai, 0);	144	snd_soc_dai_digital_mute(codec_dai, 0);
145	else if (cmd == SNDRV_PCM_TRIGGER_STOP)	145	else if (cmd == SNDRV_PCM_TRIGGER_STOP)
146	snd_soc_dai_digital_mute(codec_dai, 1);	146	snd_soc_dai_digital_mute(codec_dai, 1);
147		147
148	return ret;	148	return ret;
149	}	149	}
150		150
151	static int soc_compr_set_params(struct snd_compr_stream *cstream,	151	static int soc_compr_set_params(struct snd_compr_stream *cstream,
152	struct snd_compr_params *params)	152	struct snd_compr_params *params)
153	{	153	{
154	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	154	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
155	struct snd_soc_platform *platform = rtd->platform;	155	struct snd_soc_platform *platform = rtd->platform;
156	int ret = 0;	156	int ret = 0;
157		157
158	/* first we call set_params for the platform driver	158	/* first we call set_params for the platform driver
159	* this should configure the soc side	159	* this should configure the soc side
160	* if the machine has compressed ops then we call that as well	160	* if the machine has compressed ops then we call that as well
161	* expectation is that platform and machine will configure everything	161	* expectation is that platform and machine will configure everything
162	* for this compress path, like configuring pcm port for codec	162	* for this compress path, like configuring pcm port for codec
163	*/	163	*/
164	if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {	164	if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
165	ret = platform->driver->compr_ops->set_params(cstream, params);	165	ret = platform->driver->compr_ops->set_params(cstream, params);
166	if (ret < 0)	166	if (ret < 0)
167	return ret;	167	return ret;
168	}	168	}
169		169
170	if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {	170	if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
171	ret = rtd->dai_link->compr_ops->set_params(cstream);	171	ret = rtd->dai_link->compr_ops->set_params(cstream);
172	if (ret < 0)	172	if (ret < 0)
173	return ret;	173	return ret;
174	}	174	}
175		175
176	snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,	176	snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
177	SND_SOC_DAPM_STREAM_START);	177	SND_SOC_DAPM_STREAM_START);
178		178
179	return ret;	179	return ret;
180	}	180	}
181		181
182	static int soc_compr_get_params(struct snd_compr_stream *cstream,	182	static int soc_compr_get_params(struct snd_compr_stream *cstream,
183	struct snd_codec *params)	183	struct snd_codec *params)
184	{	184	{
185	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	185	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
186	struct snd_soc_platform *platform = rtd->platform;	186	struct snd_soc_platform *platform = rtd->platform;
187	int ret = 0;	187	int ret = 0;
188		188
189	if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)	189	if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)
190	ret = platform->driver->compr_ops->get_params(cstream, params);	190	ret = platform->driver->compr_ops->get_params(cstream, params);
191		191
192	return ret;	192	return ret;
193	}	193	}
194		194
195	static int soc_compr_get_caps(struct snd_compr_stream *cstream,	195	static int soc_compr_get_caps(struct snd_compr_stream *cstream,
196	struct snd_compr_caps *caps)	196	struct snd_compr_caps *caps)
197	{	197	{
198	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	198	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
199	struct snd_soc_platform *platform = rtd->platform;	199	struct snd_soc_platform *platform = rtd->platform;
200	int ret = 0;	200	int ret = 0;
201		201
202	if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)	202	if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)
203	ret = platform->driver->compr_ops->get_caps(cstream, caps);	203	ret = platform->driver->compr_ops->get_caps(cstream, caps);
204		204
205	return ret;	205	return ret;
206	}	206	}
207		207
208	static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,	208	static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
209	struct snd_compr_codec_caps *codec)	209	struct snd_compr_codec_caps *codec)
210	{	210	{
211	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	211	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
212	struct snd_soc_platform *platform = rtd->platform;	212	struct snd_soc_platform *platform = rtd->platform;
213	int ret = 0;	213	int ret = 0;
214		214
215	if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps)	215	if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps)
216	ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);	216	ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
217		217
218	return ret;	218	return ret;
219	}	219	}
220		220
221	static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)	221	static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
222	{	222	{
223	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	223	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
224	struct snd_soc_platform *platform = rtd->platform;	224	struct snd_soc_platform *platform = rtd->platform;
225	int ret = 0;	225	int ret = 0;
226		226
227	if (platform->driver->compr_ops && platform->driver->compr_ops->ack)	227	if (platform->driver->compr_ops && platform->driver->compr_ops->ack)
228	ret = platform->driver->compr_ops->ack(cstream, bytes);	228	ret = platform->driver->compr_ops->ack(cstream, bytes);
229		229
230	return ret;	230	return ret;
231	}	231	}
232		232
233	static int soc_compr_pointer(struct snd_compr_stream *cstream,	233	static int soc_compr_pointer(struct snd_compr_stream *cstream,
234	struct snd_compr_tstamp *tstamp)	234	struct snd_compr_tstamp *tstamp)
235	{	235	{
236	struct snd_soc_pcm_runtime *rtd = cstream->private_data;	236	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
237	struct snd_soc_platform *platform = rtd->platform;	237	struct snd_soc_platform *platform = rtd->platform;
238		238
239	if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)	239	if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)
240	platform->driver->compr_ops->pointer(cstream, tstamp);	240	platform->driver->compr_ops->pointer(cstream, tstamp);
241		241
242	return 0;	242	return 0;
243	}	243	}
244		244
245	/* ASoC Compress operations */	245	/* ASoC Compress operations */
246	static struct snd_compr_ops soc_compr_ops = {	246	static struct snd_compr_ops soc_compr_ops = {
247	.open = soc_compr_open,	247	.open = soc_compr_open,
248	.free = soc_compr_free,	248	.free = soc_compr_free,
249	.set_params = soc_compr_set_params,	249	.set_params = soc_compr_set_params,
250	.get_params = soc_compr_get_params,	250	.get_params = soc_compr_get_params,
251	.trigger = soc_compr_trigger,	251	.trigger = soc_compr_trigger,
252	.pointer = soc_compr_pointer,	252	.pointer = soc_compr_pointer,
253	.ack = soc_compr_ack,	253	.ack = soc_compr_ack,
254	.get_caps = soc_compr_get_caps,	254	.get_caps = soc_compr_get_caps,
255	.get_codec_caps = soc_compr_get_codec_caps	255	.get_codec_caps = soc_compr_get_codec_caps
256	};	256	};
257		257
258	/* create a new compress */	258	/* create a new compress */
259	int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)	259	int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
260	{	260	{
261	struct snd_soc_codec *codec = rtd->codec;	261	struct snd_soc_codec *codec = rtd->codec;
262	struct snd_soc_dai *codec_dai = rtd->codec_dai;	262	struct snd_soc_dai *codec_dai = rtd->codec_dai;
263	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;	263	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
264	struct snd_compr *compr;	264	struct snd_compr *compr;
265	char new_name[64];	265	char new_name[64];
266	int ret = 0, direction = 0;	266	int ret = 0, direction = 0;
267		267
268	/* check client and interface hw capabilities */	268	/* check client and interface hw capabilities */
269	snprintf(new_name, sizeof(new_name), "%s %s-%d",	269	snprintf(new_name, sizeof(new_name), "%s %s-%d",
270	rtd->dai_link->stream_name, codec_dai->name, num);	270	rtd->dai_link->stream_name, codec_dai->name, num);
271	direction = SND_COMPRESS_PLAYBACK;	271	direction = SND_COMPRESS_PLAYBACK;
272	compr = kzalloc(sizeof(*compr), GFP_KERNEL);	272	compr = kzalloc(sizeof(*compr), GFP_KERNEL);
273	if (compr == NULL) {	273	if (compr == NULL) {
274	snd_printk(KERN_ERR "Cannot allocate compr\n");	274	snd_printk(KERN_ERR "Cannot allocate compr\n");
275	return -ENOMEM;	275	return -ENOMEM;
276	}	276	}
277		277
278	compr->ops = &soc_compr_ops;	278	compr->ops = &soc_compr_ops;
279	mutex_init(&compr->lock);	279	mutex_init(&compr->lock);
280	ret = snd_compress_new(rtd->card->snd_card, num, direction, compr);	280	ret = snd_compress_new(rtd->card->snd_card, num, direction, compr);
281	if (ret < 0) {	281	if (ret < 0) {
282	pr_err("compress asoc: can't create compress for codec %s\n",	282	pr_err("compress asoc: can't create compress for codec %s\n",
283	codec->name);	283	codec->name);
284	kfree(compr);	284	kfree(compr);
285	return ret;	285	return ret;
286	}	286	}
287		287
288	rtd->compr = compr;	288	rtd->compr = compr;
289	compr->private_data = rtd;	289	compr->private_data = rtd;
290		290
291	printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,	291	printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name,
292	cpu_dai->name);	292	cpu_dai->name);
293	return ret;	293	return ret;
294	}	294	}
295		295

sound/soc/soc-pcm.c

Diff comments View file @ 9bffb1f

1	/*	1	/*
2	* soc-pcm.c -- ALSA SoC PCM	2	* soc-pcm.c -- ALSA SoC PCM
3	*	3	*
4	* Copyright 2005 Wolfson Microelectronics PLC.	4	* Copyright 2005 Wolfson Microelectronics PLC.
5	* Copyright 2005 Openedhand Ltd.	5	* Copyright 2005 Openedhand Ltd.
6	* Copyright (C) 2010 Slimlogic Ltd.	6	* Copyright (C) 2010 Slimlogic Ltd.
7	* Copyright (C) 2010 Texas Instruments Inc.	7	* Copyright (C) 2010 Texas Instruments Inc.
8	*	8	*
9	* Authors: Liam Girdwood <lrg@ti.com>	9	* Authors: Liam Girdwood <lrg@ti.com>
10	* Mark Brown <broonie@opensource.wolfsonmicro.com>	10	* Mark Brown <broonie@opensource.wolfsonmicro.com>
11	*	11	*
12	* This program is free software; you can redistribute it and/or modify it	12	* This program is free software; you can redistribute it and/or modify it
13	* under the terms of the GNU General Public License as published by the	13	* under the terms of the GNU General Public License as published by the
14	* Free Software Foundation; either version 2 of the License, or (at your	14	* Free Software Foundation; either version 2 of the License, or (at your
15	* option) any later version.	15	* option) any later version.
16	*	16	*
17	*/	17	*/
18		18
19	#include <linux/kernel.h>	19	#include <linux/kernel.h>
20	#include <linux/init.h>	20	#include <linux/init.h>
21	#include <linux/delay.h>	21	#include <linux/delay.h>
22	#include <linux/pm_runtime.h>	22	#include <linux/pm_runtime.h>
23	#include <linux/slab.h>	23	#include <linux/slab.h>
24	#include <linux/workqueue.h>	24	#include <linux/workqueue.h>
25	#include <linux/export.h>	25	#include <linux/export.h>
26	#include <linux/debugfs.h>	26	#include <linux/debugfs.h>
27	#include <sound/core.h>	27	#include <sound/core.h>
28	#include <sound/pcm.h>	28	#include <sound/pcm.h>
29	#include <sound/pcm_params.h>	29	#include <sound/pcm_params.h>
30	#include <sound/soc.h>	30	#include <sound/soc.h>
31	#include <sound/soc-dpcm.h>	31	#include <sound/soc-dpcm.h>
32	#include <sound/initval.h>	32	#include <sound/initval.h>
33		33
34	#define DPCM_MAX_BE_USERS 8	34	#define DPCM_MAX_BE_USERS 8
35		35
36	/* DPCM stream event, send event to FE and all active BEs. */	36	/* DPCM stream event, send event to FE and all active BEs. */
37	static int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,	37	static int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
38	int event)	38	int event)
39	{	39	{
40	struct snd_soc_dpcm *dpcm;	40	struct snd_soc_dpcm *dpcm;