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_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