1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // soc-util.c -- ALSA SoC Audio Layer utility functions 4 // 5 // Copyright 2009 Wolfson Microelectronics PLC. 6 // 7 // Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 8 // Liam Girdwood <lrg@slimlogic.co.uk> 9 10 #include <linux/platform_device.h> 11 #include <linux/export.h> 12 #include <linux/math.h> 13 #include <sound/core.h> 14 #include <sound/pcm.h> 15 #include <sound/pcm_params.h> 16 #include <sound/soc.h> 17 18 int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots) 19 { 20 return sample_size * channels * tdm_slots; 21 } 22 EXPORT_SYMBOL_GPL(snd_soc_calc_frame_size); 23 24 int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params) 25 { 26 int sample_size; 27 28 sample_size = snd_pcm_format_width(params_format(params)); 29 if (sample_size < 0) 30 return sample_size; 31 32 return snd_soc_calc_frame_size(sample_size, params_channels(params), 33 1); 34 } 35 EXPORT_SYMBOL_GPL(snd_soc_params_to_frame_size); 36 37 int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots) 38 { 39 return fs * snd_soc_calc_frame_size(sample_size, channels, tdm_slots); 40 } 41 EXPORT_SYMBOL_GPL(snd_soc_calc_bclk); 42 43 int snd_soc_params_to_bclk(struct snd_pcm_hw_params *params) 44 { 45 int ret; 46 47 ret = snd_soc_params_to_frame_size(params); 48 49 if (ret > 0) 50 return ret * params_rate(params); 51 else 52 return ret; 53 } 54 EXPORT_SYMBOL_GPL(snd_soc_params_to_bclk); 55 56 /** 57 * snd_soc_tdm_params_to_bclk - calculate bclk from params and tdm slot info. 58 * 59 * Calculate the bclk from the params sample rate and the tdm slot count and 60 * tdm slot width. Either or both of tdm_width and tdm_slots can be 0. 61 * 62 * If tdm_width == 0 and tdm_slots > 0: the params_width will be used. 63 * If tdm_width > 0 and tdm_slots == 0: the params_channels will be used 64 * as the slot count. 65 * Both tdm_width and tdm_slots are 0: this is equivalent to calling 66 * snd_soc_params_to_bclk(). 67 * 68 * If slot_multiple > 1 the slot count (or params_channels if tdm_slots == 0) 69 * will be rounded up to a multiple of this value. This is mainly useful for 70 * I2S mode, which has a left and right phase so the number of slots is always 71 * a multiple of 2. 72 * 73 * @params: Pointer to struct_pcm_hw_params. 74 * @tdm_width: Width in bits of the tdm slots. 75 * @tdm_slots: Number of tdm slots per frame. 76 * @slot_multiple: If >1 roundup slot count to a multiple of this value. 77 * 78 * Return: bclk frequency in Hz, else a negative error code if params format 79 * is invalid. 80 */ 81 int snd_soc_tdm_params_to_bclk(struct snd_pcm_hw_params *params, 82 int tdm_width, int tdm_slots, int slot_multiple) 83 { 84 if (!tdm_slots) 85 tdm_slots = params_channels(params); 86 87 if (slot_multiple > 1) 88 tdm_slots = roundup(tdm_slots, slot_multiple); 89 90 if (!tdm_width) { 91 tdm_width = snd_pcm_format_width(params_format(params)); 92 if (tdm_width < 0) 93 return tdm_width; 94 } 95 96 return snd_soc_calc_bclk(params_rate(params), tdm_width, 1, tdm_slots); 97 } 98 EXPORT_SYMBOL_GPL(snd_soc_tdm_params_to_bclk); 99 100 static const struct snd_pcm_hardware dummy_dma_hardware = { 101 /* Random values to keep userspace happy when checking constraints */ 102 .info = SNDRV_PCM_INFO_INTERLEAVED | 103 SNDRV_PCM_INFO_BLOCK_TRANSFER, 104 .buffer_bytes_max = 128*1024, 105 .period_bytes_min = PAGE_SIZE, 106 .period_bytes_max = PAGE_SIZE*2, 107 .periods_min = 2, 108 .periods_max = 128, 109 }; 110 111 112 static const struct snd_soc_component_driver dummy_platform; 113 114 static int dummy_dma_open(struct snd_soc_component *component, 115 struct snd_pcm_substream *substream) 116 { 117 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 118 int i; 119 120 /* 121 * If there are other components associated with rtd, we shouldn't 122 * override their hwparams 123 */ 124 for_each_rtd_components(rtd, i, component) { 125 if (component->driver == &dummy_platform) 126 return 0; 127 } 128 129 /* BE's dont need dummy params */ 130 if (!rtd->dai_link->no_pcm) 131 snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware); 132 133 return 0; 134 } 135 136 static const struct snd_soc_component_driver dummy_platform = { 137 .open = dummy_dma_open, 138 }; 139 140 static const struct snd_soc_component_driver dummy_codec = { 141 .idle_bias_on = 1, 142 .use_pmdown_time = 1, 143 .endianness = 1, 144 .non_legacy_dai_naming = 1, 145 }; 146 147 #define STUB_RATES SNDRV_PCM_RATE_8000_384000 148 #define STUB_FORMATS (SNDRV_PCM_FMTBIT_S8 | \ 149 SNDRV_PCM_FMTBIT_U8 | \ 150 SNDRV_PCM_FMTBIT_S16_LE | \ 151 SNDRV_PCM_FMTBIT_U16_LE | \ 152 SNDRV_PCM_FMTBIT_S24_LE | \ 153 SNDRV_PCM_FMTBIT_S24_3LE | \ 154 SNDRV_PCM_FMTBIT_U24_LE | \ 155 SNDRV_PCM_FMTBIT_S32_LE | \ 156 SNDRV_PCM_FMTBIT_U32_LE | \ 157 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE) 158 159 /* 160 * Select these from Sound Card Manually 161 * SND_SOC_POSSIBLE_DAIFMT_CBP_CFP 162 * SND_SOC_POSSIBLE_DAIFMT_CBP_CFC 163 * SND_SOC_POSSIBLE_DAIFMT_CBC_CFP 164 * SND_SOC_POSSIBLE_DAIFMT_CBC_CFC 165 */ 166 static u64 dummy_dai_formats = 167 SND_SOC_POSSIBLE_DAIFMT_I2S | 168 SND_SOC_POSSIBLE_DAIFMT_RIGHT_J | 169 SND_SOC_POSSIBLE_DAIFMT_LEFT_J | 170 SND_SOC_POSSIBLE_DAIFMT_DSP_A | 171 SND_SOC_POSSIBLE_DAIFMT_DSP_B | 172 SND_SOC_POSSIBLE_DAIFMT_AC97 | 173 SND_SOC_POSSIBLE_DAIFMT_PDM | 174 SND_SOC_POSSIBLE_DAIFMT_GATED | 175 SND_SOC_POSSIBLE_DAIFMT_CONT | 176 SND_SOC_POSSIBLE_DAIFMT_NB_NF | 177 SND_SOC_POSSIBLE_DAIFMT_NB_IF | 178 SND_SOC_POSSIBLE_DAIFMT_IB_NF | 179 SND_SOC_POSSIBLE_DAIFMT_IB_IF; 180 181 static const struct snd_soc_dai_ops dummy_dai_ops = { 182 .auto_selectable_formats = &dummy_dai_formats, 183 .num_auto_selectable_formats = 1, 184 }; 185 186 /* 187 * The dummy CODEC is only meant to be used in situations where there is no 188 * actual hardware. 189 * 190 * If there is actual hardware even if it does not have a control bus 191 * the hardware will still have constraints like supported samplerates, etc. 192 * which should be modelled. And the data flow graph also should be modelled 193 * using DAPM. 194 */ 195 static struct snd_soc_dai_driver dummy_dai = { 196 .name = "snd-soc-dummy-dai", 197 .playback = { 198 .stream_name = "Playback", 199 .channels_min = 1, 200 .channels_max = 384, 201 .rates = STUB_RATES, 202 .formats = STUB_FORMATS, 203 }, 204 .capture = { 205 .stream_name = "Capture", 206 .channels_min = 1, 207 .channels_max = 384, 208 .rates = STUB_RATES, 209 .formats = STUB_FORMATS, 210 }, 211 .ops = &dummy_dai_ops, 212 }; 213 214 int snd_soc_dai_is_dummy(struct snd_soc_dai *dai) 215 { 216 if (dai->driver == &dummy_dai) 217 return 1; 218 return 0; 219 } 220 221 int snd_soc_component_is_dummy(struct snd_soc_component *component) 222 { 223 return ((component->driver == &dummy_platform) || 224 (component->driver == &dummy_codec)); 225 } 226 227 static int snd_soc_dummy_probe(struct platform_device *pdev) 228 { 229 int ret; 230 231 ret = devm_snd_soc_register_component(&pdev->dev, 232 &dummy_codec, &dummy_dai, 1); 233 if (ret < 0) 234 return ret; 235 236 ret = devm_snd_soc_register_component(&pdev->dev, &dummy_platform, 237 NULL, 0); 238 239 return ret; 240 } 241 242 static struct platform_driver soc_dummy_driver = { 243 .driver = { 244 .name = "snd-soc-dummy", 245 }, 246 .probe = snd_soc_dummy_probe, 247 }; 248 249 static struct platform_device *soc_dummy_dev; 250 251 int __init snd_soc_util_init(void) 252 { 253 int ret; 254 255 soc_dummy_dev = 256 platform_device_register_simple("snd-soc-dummy", -1, NULL, 0); 257 if (IS_ERR(soc_dummy_dev)) 258 return PTR_ERR(soc_dummy_dev); 259 260 ret = platform_driver_register(&soc_dummy_driver); 261 if (ret != 0) 262 platform_device_unregister(soc_dummy_dev); 263 264 return ret; 265 } 266 267 void __exit snd_soc_util_exit(void) 268 { 269 platform_driver_unregister(&soc_dummy_driver); 270 platform_device_unregister(soc_dummy_dev); 271 } 272