Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/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 struct snd_soc_platform_driver dummy_platform = {
288         .ops = &dummy_dma_ops,
289 };
290 
291 static struct snd_soc_codec_driver dummy_codec;
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)
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  */
312 static struct snd_soc_dai_driver dummy_dai = {
313         .name = "snd-soc-dummy-dai",
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          },
328 };
329 
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 
337 static int snd_soc_dummy_probe(struct platform_device *pdev)
338 {
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;
352 }
353 
354 static int snd_soc_dummy_remove(struct platform_device *pdev)
355 {
356         snd_soc_unregister_platform(&pdev->dev);
357         snd_soc_unregister_codec(&pdev->dev);
358 
359         return 0;
360 }
361 
362 static struct platform_driver soc_dummy_driver = {
363         .driver = {
364                 .name = "snd-soc-dummy",
365         },
366         .probe = snd_soc_dummy_probe,
367         .remove = snd_soc_dummy_remove,
368 };
369 
370 static struct platform_device *soc_dummy_dev;
371 
372 int __init snd_soc_util_init(void)
373 {
374         int ret;
375 
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);
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 }
387 
388 void __exit snd_soc_util_exit(void)
389 {
390         platform_device_unregister(soc_dummy_dev);
391         platform_driver_unregister(&soc_dummy_driver);
392 }
393 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us