~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/soc-utils.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_device_unregister(soc_dummy_dev);
385         platform_driver_unregister(&soc_dummy_driver);
386 }
387 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp