a863bb3f66c21ad8af277cbd6613ea6521a1e702
[muen/linux.git] / sound / soc / soc-utils.c
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
16 #include <linux/platform_device.h>
17 #include <linux/export.h>
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
33         sample_size = snd_pcm_format_width(params_format(params));
34         if (sample_size < 0)
35                 return sample_size;
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
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
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);
60
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
260 static const struct snd_pcm_hardware dummy_dma_hardware = {
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 {
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);
278
279         return 0;
280 }
281
282 static const struct snd_pcm_ops dummy_dma_ops = {
283         .open           = dummy_dma_open,
284         .ioctl          = snd_pcm_lib_ioctl,
285 };
286
287 static const struct snd_soc_component_driver dummy_platform = {
288         .ops = &dummy_dma_ops,
289 };
290
291 static const struct snd_soc_component_driver dummy_codec = {
292         .idle_bias_on           = 1,
293         .use_pmdown_time        = 1,
294         .endianness             = 1,
295         .non_legacy_dai_naming  = 1,
296 };
297
298 #define STUB_RATES      SNDRV_PCM_RATE_8000_192000
299 #define STUB_FORMATS    (SNDRV_PCM_FMTBIT_S8 | \
300                         SNDRV_PCM_FMTBIT_U8 | \
301                         SNDRV_PCM_FMTBIT_S16_LE | \
302                         SNDRV_PCM_FMTBIT_U16_LE | \
303                         SNDRV_PCM_FMTBIT_S24_LE | \
304                         SNDRV_PCM_FMTBIT_U24_LE | \
305                         SNDRV_PCM_FMTBIT_S32_LE | \
306                         SNDRV_PCM_FMTBIT_U32_LE | \
307                         SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
308 /*
309  * The dummy CODEC is only meant to be used in situations where there is no
310  * actual hardware.
311  *
312  * If there is actual hardware even if it does not have a control bus
313  * the hardware will still have constraints like supported samplerates, etc.
314  * which should be modelled. And the data flow graph also should be modelled
315  * using DAPM.
316  */
317 static struct snd_soc_dai_driver dummy_dai = {
318         .name = "snd-soc-dummy-dai",
319         .playback = {
320                 .stream_name    = "Playback",
321                 .channels_min   = 1,
322                 .channels_max   = 384,
323                 .rates          = STUB_RATES,
324                 .formats        = STUB_FORMATS,
325         },
326         .capture = {
327                 .stream_name    = "Capture",
328                 .channels_min   = 1,
329                 .channels_max   = 384,
330                 .rates = STUB_RATES,
331                 .formats = STUB_FORMATS,
332          },
333 };
334
335 int snd_soc_dai_is_dummy(struct snd_soc_dai *dai)
336 {
337         if (dai->driver == &dummy_dai)
338                 return 1;
339         return 0;
340 }
341
342 static int snd_soc_dummy_probe(struct platform_device *pdev)
343 {
344         int ret;
345
346         ret = devm_snd_soc_register_component(&pdev->dev,
347                                               &dummy_codec, &dummy_dai, 1);
348         if (ret < 0)
349                 return ret;
350
351         ret = devm_snd_soc_register_component(&pdev->dev, &dummy_platform,
352                                               NULL, 0);
353
354         return ret;
355 }
356
357 static struct platform_driver soc_dummy_driver = {
358         .driver = {
359                 .name = "snd-soc-dummy",
360         },
361         .probe = snd_soc_dummy_probe,
362 };
363
364 static struct platform_device *soc_dummy_dev;
365
366 int __init snd_soc_util_init(void)
367 {
368         int ret;
369
370         soc_dummy_dev =
371                 platform_device_register_simple("snd-soc-dummy", -1, NULL, 0);
372         if (IS_ERR(soc_dummy_dev))
373                 return PTR_ERR(soc_dummy_dev);
374
375         ret = platform_driver_register(&soc_dummy_driver);
376         if (ret != 0)
377                 platform_device_unregister(soc_dummy_dev);
378
379         return ret;
380 }
381
382 void __exit snd_soc_util_exit(void)
383 {
384         platform_driver_unregister(&soc_dummy_driver);
385         platform_device_unregister(soc_dummy_dev);
386 }