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 static const struct snd_pcm_hardware dummy_dma_hardware = { 62 /* Random values to keep userspace happy when checking constraints */ 63 .info = SNDRV_PCM_INFO_INTERLEAVED | 64 SNDRV_PCM_INFO_BLOCK_TRANSFER, 65 .buffer_bytes_max = 128*1024, 66 .period_bytes_min = PAGE_SIZE, 67 .period_bytes_max = PAGE_SIZE*2, 68 .periods_min = 2, 69 .periods_max = 128, 70 }; 71 72 static int dummy_dma_open(struct snd_pcm_substream *substream) 73 { 74 struct snd_soc_pcm_runtime *rtd = substream->private_data; 75 76 /* BE's dont need dummy params */ 77 if (!rtd->dai_link->no_pcm) 78 snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware); 79 80 return 0; 81 } 82 83 static struct snd_pcm_ops dummy_dma_ops = { 84 .open = dummy_dma_open, 85 .ioctl = snd_pcm_lib_ioctl, 86 }; 87 88 static struct snd_soc_platform_driver dummy_platform = { 89 .ops = &dummy_dma_ops, 90 }; 91 92 static struct snd_soc_codec_driver dummy_codec; 93 94 #define STUB_RATES SNDRV_PCM_RATE_8000_192000 95 #define STUB_FORMATS (SNDRV_PCM_FMTBIT_S8 | \ 96 SNDRV_PCM_FMTBIT_U8 | \ 97 SNDRV_PCM_FMTBIT_S16_LE | \ 98 SNDRV_PCM_FMTBIT_U16_LE | \ 99 SNDRV_PCM_FMTBIT_S24_LE | \ 100 SNDRV_PCM_FMTBIT_U24_LE | \ 101 SNDRV_PCM_FMTBIT_S32_LE | \ 102 SNDRV_PCM_FMTBIT_U32_LE | \ 103 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE) 104 /* 105 * The dummy CODEC is only meant to be used in situations where there is no 106 * actual hardware. 107 * 108 * If there is actual hardware even if it does not have a control bus 109 * the hardware will still have constraints like supported samplerates, etc. 110 * which should be modelled. And the data flow graph also should be modelled 111 * using DAPM. 112 */ 113 static struct snd_soc_dai_driver dummy_dai = { 114 .name = "snd-soc-dummy-dai", 115 .playback = { 116 .stream_name = "Playback", 117 .channels_min = 1, 118 .channels_max = 384, 119 .rates = STUB_RATES, 120 .formats = STUB_FORMATS, 121 }, 122 .capture = { 123 .stream_name = "Capture", 124 .channels_min = 1, 125 .channels_max = 384, 126 .rates = STUB_RATES, 127 .formats = STUB_FORMATS, 128 }, 129 }; 130 131 int snd_soc_dai_is_dummy(struct snd_soc_dai *dai) 132 { 133 if (dai->driver == &dummy_dai) 134 return 1; 135 return 0; 136 } 137 138 static int snd_soc_dummy_probe(struct platform_device *pdev) 139 { 140 int ret; 141 142 ret = snd_soc_register_codec(&pdev->dev, &dummy_codec, &dummy_dai, 1); 143 if (ret < 0) 144 return ret; 145 146 ret = snd_soc_register_platform(&pdev->dev, &dummy_platform); 147 if (ret < 0) { 148 snd_soc_unregister_codec(&pdev->dev); 149 return ret; 150 } 151 152 return ret; 153 } 154 155 static int snd_soc_dummy_remove(struct platform_device *pdev) 156 { 157 snd_soc_unregister_platform(&pdev->dev); 158 snd_soc_unregister_codec(&pdev->dev); 159 160 return 0; 161 } 162 163 static struct platform_driver soc_dummy_driver = { 164 .driver = { 165 .name = "snd-soc-dummy", 166 }, 167 .probe = snd_soc_dummy_probe, 168 .remove = snd_soc_dummy_remove, 169 }; 170 171 static struct platform_device *soc_dummy_dev; 172 173 int __init snd_soc_util_init(void) 174 { 175 int ret; 176 177 soc_dummy_dev = 178 platform_device_register_simple("snd-soc-dummy", -1, NULL, 0); 179 if (IS_ERR(soc_dummy_dev)) 180 return PTR_ERR(soc_dummy_dev); 181 182 ret = platform_driver_register(&soc_dummy_driver); 183 if (ret != 0) 184 platform_device_unregister(soc_dummy_dev); 185 186 return ret; 187 } 188 189 void __exit snd_soc_util_exit(void) 190 { 191 platform_device_unregister(soc_dummy_dev); 192 platform_driver_unregister(&soc_dummy_driver); 193 } 194