[mirror_ubuntu-bionic-kernel.git] / sound / soc / soc-utils.c

/*
 * soc-util.c  --  ALSA SoC Audio Layer utility functions
 *
 * Copyright 2009 Wolfson Microelectronics PLC.
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *         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 as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 */

#include <linux/platform_device.h>
#include <linux/export.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>

int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots)
{
	return sample_size * channels * tdm_slots;
}
EXPORT_SYMBOL_GPL(snd_soc_calc_frame_size);

int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params)
{
	int sample_size;

	sample_size = snd_pcm_format_width(params_format(params));
	if (sample_size < 0)
		return sample_size;

	return snd_soc_calc_frame_size(sample_size, params_channels(params),
				       1);
}
EXPORT_SYMBOL_GPL(snd_soc_params_to_frame_size);

int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots)
{
	return fs * snd_soc_calc_frame_size(sample_size, channels, tdm_slots);
}
EXPORT_SYMBOL_GPL(snd_soc_calc_bclk);

int snd_soc_params_to_bclk(struct snd_pcm_hw_params *params)
{
	int ret;

	ret = snd_soc_params_to_frame_size(params);

	if (ret > 0)
		return ret * params_rate(params);
	else
		return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_params_to_bclk);

int snd_soc_component_enable_pin(struct snd_soc_component *component,
				 const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_enable_pin(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_enable_pin(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin);

int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component,
					  const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_enable_pin_unlocked(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_enable_pin_unlocked(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin_unlocked);

int snd_soc_component_disable_pin(struct snd_soc_component *component,
				  const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_disable_pin(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_disable_pin(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin);

int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component,
					   const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_disable_pin_unlocked(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_disable_pin_unlocked(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin_unlocked);

int snd_soc_component_nc_pin(struct snd_soc_component *component,
			     const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_nc_pin(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_nc_pin(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin);

int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component,
				      const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_nc_pin_unlocked(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_nc_pin_unlocked(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin_unlocked);

int snd_soc_component_get_pin_status(struct snd_soc_component *component,
				     const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_get_pin_status(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_get_pin_status(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_get_pin_status);

int snd_soc_component_force_enable_pin(struct snd_soc_component *component,
				       const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_force_enable_pin(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_force_enable_pin(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin);

int snd_soc_component_force_enable_pin_unlocked(
					struct snd_soc_component *component,
					const char *pin)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	char *full_name;
	int ret;

	if (!component->name_prefix)
		return snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);

	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	if (!full_name)
		return -ENOMEM;

	ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, full_name);
	kfree(full_name);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin_unlocked);

static const struct snd_pcm_hardware dummy_dma_hardware = {
	/* Random values to keep userspace happy when checking constraints */
	.info			= SNDRV_PCM_INFO_INTERLEAVED |
				  SNDRV_PCM_INFO_BLOCK_TRANSFER,
	.buffer_bytes_max	= 128*1024,
	.period_bytes_min	= PAGE_SIZE,
	.period_bytes_max	= PAGE_SIZE*2,
	.periods_min		= 2,
	.periods_max		= 128,
};

static int dummy_dma_open(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;

	/* BE's dont need dummy params */
	if (!rtd->dai_link->no_pcm)
		snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware);

	return 0;
}

static const struct snd_pcm_ops dummy_dma_ops = {
	.open		= dummy_dma_open,
	.ioctl		= snd_pcm_lib_ioctl,
};

static const struct snd_soc_platform_driver dummy_platform = {
	.ops = &dummy_dma_ops,
};

static struct snd_soc_codec_driver dummy_codec;

#define STUB_RATES	SNDRV_PCM_RATE_8000_192000
#define STUB_FORMATS	(SNDRV_PCM_FMTBIT_S8 | \
			SNDRV_PCM_FMTBIT_U8 | \
			SNDRV_PCM_FMTBIT_S16_LE | \
			SNDRV_PCM_FMTBIT_U16_LE | \
			SNDRV_PCM_FMTBIT_S24_LE | \
			SNDRV_PCM_FMTBIT_U24_LE | \
			SNDRV_PCM_FMTBIT_S32_LE | \
			SNDRV_PCM_FMTBIT_U32_LE | \
			SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
/*
 * The dummy CODEC is only meant to be used in situations where there is no
 * actual hardware.
 *
 * If there is actual hardware even if it does not have a control bus
 * the hardware will still have constraints like supported samplerates, etc.
 * which should be modelled. And the data flow graph also should be modelled
 * using DAPM.
 */
static struct snd_soc_dai_driver dummy_dai = {
	.name = "snd-soc-dummy-dai",
	.playback = {
		.stream_name	= "Playback",
		.channels_min	= 1,
		.channels_max	= 384,
		.rates		= STUB_RATES,
		.formats	= STUB_FORMATS,
	},
	.capture = {
		.stream_name	= "Capture",
		.channels_min	= 1,
		.channels_max	= 384,
		.rates = STUB_RATES,
		.formats = STUB_FORMATS,
	 },
};

int snd_soc_dai_is_dummy(struct snd_soc_dai *dai)
{
	if (dai->driver == &dummy_dai)
		return 1;
	return 0;
}

static int snd_soc_dummy_probe(struct platform_device *pdev)
{
	int ret;

	ret = snd_soc_register_codec(&pdev->dev, &dummy_codec, &dummy_dai, 1);
	if (ret < 0)
		return ret;

	ret = snd_soc_register_platform(&pdev->dev, &dummy_platform);
	if (ret < 0) {
		snd_soc_unregister_codec(&pdev->dev);
		return ret;
	}

	return ret;
}

static int snd_soc_dummy_remove(struct platform_device *pdev)
{
	snd_soc_unregister_platform(&pdev->dev);
	snd_soc_unregister_codec(&pdev->dev);

	return 0;
}

static struct platform_driver soc_dummy_driver = {
	.driver = {
		.name = "snd-soc-dummy",
	},
	.probe = snd_soc_dummy_probe,
	.remove = snd_soc_dummy_remove,
};

static struct platform_device *soc_dummy_dev;

int __init snd_soc_util_init(void)
{
	int ret;

	soc_dummy_dev =
		platform_device_register_simple("snd-soc-dummy", -1, NULL, 0);
	if (IS_ERR(soc_dummy_dev))
		return PTR_ERR(soc_dummy_dev);

	ret = platform_driver_register(&soc_dummy_driver);
	if (ret != 0)
		platform_device_unregister(soc_dummy_dev);

	return ret;
}

void __exit snd_soc_util_exit(void)
{
	platform_device_unregister(soc_dummy_dev);
	platform_driver_unregister(&soc_dummy_driver);
}
Commit	Line	Data
7aae816d MB	1	/*
	2	* soc-util.c -- ALSA SoC Audio Layer utility functions
	3	*
	4	* Copyright 2009 Wolfson Microelectronics PLC.
	5	*
	6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
	7	* Liam Girdwood <lrg@slimlogic.co.uk>
	8	*
	9	*
	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
	12	* Free Software Foundation; either version 2 of the License, or (at your
	13	* option) any later version.
	14	*/
	15
848dd8be	16	#include <linux/platform_device.h>
d81a6d71	17	#include <linux/export.h>
7aae816d MB	18	#include <sound/core.h>
	19	#include <sound/pcm.h>
	20	#include <sound/pcm_params.h>
	21	#include <sound/soc.h>
	22
	23	int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots)
	24	{
	25	return sample_size * channels * tdm_slots;
	26	}
	27	EXPORT_SYMBOL_GPL(snd_soc_calc_frame_size);
	28
	29	int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params)
	30	{
	31	int sample_size;
	32
3d8b2ce0 MB	33	sample_size = snd_pcm_format_width(params_format(params));
	34	if (sample_size < 0)
	35	return sample_size;
7aae816d MB	36
	37	return snd_soc_calc_frame_size(sample_size, params_channels(params),
	38	1);
	39	}
	40	EXPORT_SYMBOL_GPL(snd_soc_params_to_frame_size);
	41
c0fa59df MB	42	int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots)
	43	{
	44	return fs * snd_soc_calc_frame_size(sample_size, channels, tdm_slots);
	45	}
	46	EXPORT_SYMBOL_GPL(snd_soc_calc_bclk);
	47
7aae816d MB	48	int snd_soc_params_to_bclk(struct snd_pcm_hw_params *params)
	49	{
	50	int ret;
	51
	52	ret = snd_soc_params_to_frame_size(params);
	53
	54	if (ret > 0)
	55	return ret * params_rate(params);
	56	else
	57	return ret;
	58	}
	59	EXPORT_SYMBOL_GPL(snd_soc_params_to_bclk);
848dd8be	60
1b4d9c22 RF	61	int snd_soc_component_enable_pin(struct snd_soc_component *component,
	62	const char *pin)
	63	{
	64	struct snd_soc_dapm_context *dapm =
	65	snd_soc_component_get_dapm(component);
	66	char *full_name;
	67	int ret;
	68
	69	if (!component->name_prefix)
	70	return snd_soc_dapm_enable_pin(dapm, pin);
	71
	72	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	73	if (!full_name)
	74	return -ENOMEM;
	75
	76	ret = snd_soc_dapm_enable_pin(dapm, full_name);
	77	kfree(full_name);
	78
	79	return ret;
	80	}
	81	EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin);
	82
	83	int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component,
	84	const char *pin)
	85	{
	86	struct snd_soc_dapm_context *dapm =
	87	snd_soc_component_get_dapm(component);
	88	char *full_name;
	89	int ret;
	90
	91	if (!component->name_prefix)
	92	return snd_soc_dapm_enable_pin_unlocked(dapm, pin);
	93
	94	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	95	if (!full_name)
	96	return -ENOMEM;
	97
	98	ret = snd_soc_dapm_enable_pin_unlocked(dapm, full_name);
	99	kfree(full_name);
	100
	101	return ret;
	102	}
	103	EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin_unlocked);
	104
	105	int snd_soc_component_disable_pin(struct snd_soc_component *component,
	106	const char *pin)
	107	{
	108	struct snd_soc_dapm_context *dapm =
	109	snd_soc_component_get_dapm(component);
	110	char *full_name;
	111	int ret;
	112
	113	if (!component->name_prefix)
	114	return snd_soc_dapm_disable_pin(dapm, pin);
	115
	116	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
	117	if (!full_name)
	118	return -ENOMEM;
	119
	120	ret = snd_soc_dapm_disable_pin(dapm, full_name);
	121	kfree(full_name);
	122
	123	return ret;
	124	}
125	EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin);
126
127	int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component,
128	const char *pin)
129	{
130	struct snd_soc_dapm_context *dapm =
131	snd_soc_component_get_dapm(component);
132	char *full_name;
133	int ret;
134
135	if (!component->name_prefix)
136	return snd_soc_dapm_disable_pin_unlocked(dapm, pin);
137
138	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
139	if (!full_name)
140	return -ENOMEM;
141
142	ret = snd_soc_dapm_disable_pin_unlocked(dapm, full_name);
143	kfree(full_name);
144
145	return ret;
146	}
147	EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin_unlocked);
148
149	int snd_soc_component_nc_pin(struct snd_soc_component *component,
150	const char *pin)
151	{
152	struct snd_soc_dapm_context *dapm =
153	snd_soc_component_get_dapm(component);
154	char *full_name;
155	int ret;
156
157	if (!component->name_prefix)
158	return snd_soc_dapm_nc_pin(dapm, pin);
159
160	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
161	if (!full_name)
162	return -ENOMEM;
163
164	ret = snd_soc_dapm_nc_pin(dapm, full_name);
165	kfree(full_name);
166
167	return ret;
168	}
169	EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin);
170
171	int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component,
172	const char *pin)
173	{
174	struct snd_soc_dapm_context *dapm =
175	snd_soc_component_get_dapm(component);
176	char *full_name;
177	int ret;
178
179	if (!component->name_prefix)
180	return snd_soc_dapm_nc_pin_unlocked(dapm, pin);
181
182	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
183	if (!full_name)
184	return -ENOMEM;
185
186	ret = snd_soc_dapm_nc_pin_unlocked(dapm, full_name);
187	kfree(full_name);
188
189	return ret;
190	}
191	EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin_unlocked);
192
193	int snd_soc_component_get_pin_status(struct snd_soc_component *component,
194	const char *pin)
195	{
196	struct snd_soc_dapm_context *dapm =
197	snd_soc_component_get_dapm(component);
198	char *full_name;
199	int ret;
200
201	if (!component->name_prefix)
202	return snd_soc_dapm_get_pin_status(dapm, pin);
203
204	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
205	if (!full_name)
206	return -ENOMEM;
207
208	ret = snd_soc_dapm_get_pin_status(dapm, full_name);
209	kfree(full_name);
210
211	return ret;
212	}
213	EXPORT_SYMBOL_GPL(snd_soc_component_get_pin_status);
214
215	int snd_soc_component_force_enable_pin(struct snd_soc_component *component,
216	const char *pin)
217	{
218	struct snd_soc_dapm_context *dapm =
219	snd_soc_component_get_dapm(component);
220	char *full_name;
221	int ret;
222
223	if (!component->name_prefix)
224	return snd_soc_dapm_force_enable_pin(dapm, pin);
225
226	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
227	if (!full_name)
228	return -ENOMEM;
229
230	ret = snd_soc_dapm_force_enable_pin(dapm, full_name);
231	kfree(full_name);
232
233	return ret;
234	}
235	EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin);
236
237	int snd_soc_component_force_enable_pin_unlocked(
238	struct snd_soc_component *component,
239	const char *pin)
240	{
241	struct snd_soc_dapm_context *dapm =
242	snd_soc_component_get_dapm(component);
243	char *full_name;
244	int ret;
245
246	if (!component->name_prefix)
247	return snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
248
249	full_name = kasprintf(GFP_KERNEL, "%s %s", component->name_prefix, pin);
250	if (!full_name)
251	return -ENOMEM;
252
253	ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, full_name);
254	kfree(full_name);
255
256	return ret;
257	}
258	EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin_unlocked);
259
cefcc03f	260	static const struct snd_pcm_hardware dummy_dma_hardware = {
cefcc03f MB	261	/* Random values to keep userspace happy when checking constraints */
	262	.info = SNDRV_PCM_INFO_INTERLEAVED \|
	263	SNDRV_PCM_INFO_BLOCK_TRANSFER,
	264	.buffer_bytes_max = 128*1024,
	265	.period_bytes_min = PAGE_SIZE,
	266	.period_bytes_max = PAGE_SIZE*2,
	267	.periods_min = 2,
	268	.periods_max = 128,
	269	};
	270
	271	static int dummy_dma_open(struct snd_pcm_substream *substream)
	272	{
7f05cc98 LG	273	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	274
	275	/* BE's dont need dummy params */
	276	if (!rtd->dai_link->no_pcm)
	277	snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware);
cefcc03f MB	278
	279	return 0;
	280	}
	281
115c7254	282	static const struct snd_pcm_ops dummy_dma_ops = {
cefcc03f MB	283	.open = dummy_dma_open,
	284	.ioctl = snd_pcm_lib_ioctl,
	285	};
	286
c9f3d344	287	static const struct snd_soc_platform_driver dummy_platform = {
cefcc03f MB	288	.ops = &dummy_dma_ops,
cefcc03f MB	289	};
848dd8be	290
7aca69f9	291	static struct snd_soc_codec_driver dummy_codec;
60b6f1a1 SS	292
	293	#define STUB_RATES SNDRV_PCM_RATE_8000_192000
	294	#define STUB_FORMATS (SNDRV_PCM_FMTBIT_S8 \| \
	295	SNDRV_PCM_FMTBIT_U8 \| \
	296	SNDRV_PCM_FMTBIT_S16_LE \| \
	297	SNDRV_PCM_FMTBIT_U16_LE \| \
	298	SNDRV_PCM_FMTBIT_S24_LE \| \
	299	SNDRV_PCM_FMTBIT_U24_LE \| \
	300	SNDRV_PCM_FMTBIT_S32_LE \| \
	301	SNDRV_PCM_FMTBIT_U32_LE \| \
	302	SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
d76f4198 AP	303	/*
	304	* The dummy CODEC is only meant to be used in situations where there is no
	305	* actual hardware.
	306	*
	307	* If there is actual hardware even if it does not have a control bus
	308	* the hardware will still have constraints like supported samplerates, etc.
	309	* which should be modelled. And the data flow graph also should be modelled
	310	* using DAPM.
	311	*/
7aca69f9 LG	312	static struct snd_soc_dai_driver dummy_dai = {
7aca69f9 LG	313	.name = "snd-soc-dummy-dai",
60b6f1a1 SS	314	.playback = {
	315	.stream_name = "Playback",
	316	.channels_min = 1,
	317	.channels_max = 384,
	318	.rates = STUB_RATES,
	319	.formats = STUB_FORMATS,
	320	},
	321	.capture = {
	322	.stream_name = "Capture",
	323	.channels_min = 1,
	324	.channels_max = 384,
	325	.rates = STUB_RATES,
	326	.formats = STUB_FORMATS,
	327	},
7aca69f9 LG	328	};
7aca69f9 LG	329
bece9e95 LG	330	int snd_soc_dai_is_dummy(struct snd_soc_dai *dai)
	331	{
	332	if (dai->driver == &dummy_dai)
	333	return 1;
	334	return 0;
	335	}
	336
e51e97ee	337	static int snd_soc_dummy_probe(struct platform_device *pdev)
848dd8be	338	{
7aca69f9 LG	339	int ret;
	340
	341	ret = snd_soc_register_codec(&pdev->dev, &dummy_codec, &dummy_dai, 1);
	342	if (ret < 0)
	343	return ret;
	344
	345	ret = snd_soc_register_platform(&pdev->dev, &dummy_platform);
	346	if (ret < 0) {
	347	snd_soc_unregister_codec(&pdev->dev);
	348	return ret;
	349	}
	350
	351	return ret;
848dd8be MB	352	}
848dd8be MB	353
e51e97ee	354	static int snd_soc_dummy_remove(struct platform_device *pdev)
848dd8be MB	355	{
848dd8be MB	356	snd_soc_unregister_platform(&pdev->dev);
7aca69f9	357	snd_soc_unregister_codec(&pdev->dev);
848dd8be MB	358
	359	return 0;
	360	}
	361
	362	static struct platform_driver soc_dummy_driver = {
	363	.driver = {
	364	.name = "snd-soc-dummy",
848dd8be MB	365	},
848dd8be MB	366	.probe = snd_soc_dummy_probe,
e51e97ee	367	.remove = snd_soc_dummy_remove,
848dd8be MB	368	};
	369
	370	static struct platform_device *soc_dummy_dev;
	371
fb257897	372	int __init snd_soc_util_init(void)
848dd8be MB	373	{
	374	int ret;
	375
7d0cd223 UKK	376	soc_dummy_dev =
	377	platform_device_register_simple("snd-soc-dummy", -1, NULL, 0);
	378	if (IS_ERR(soc_dummy_dev))
	379	return PTR_ERR(soc_dummy_dev);
848dd8be MB	380
	381	ret = platform_driver_register(&soc_dummy_driver);
	382	if (ret != 0)
	383	platform_device_unregister(soc_dummy_dev);
	384
	385	return ret;
	386	}
848dd8be	387
fb257897	388	void __exit snd_soc_util_exit(void)
848dd8be MB	389	{
	390	platform_device_unregister(soc_dummy_dev);
	391	platform_driver_unregister(&soc_dummy_driver);
	392	}