sound/soc/soc-utils.c

   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 <sound/core.h>
  13 #include <sound/pcm.h>
  14 #include <sound/pcm_params.h>
  15 #include <sound/soc.h>
  16
  17 int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots)
  18 {
  19         return sample_size * channels * tdm_slots;
  20 }
  21 EXPORT_SYMBOL_GPL(snd_soc_calc_frame_size);
  22
  23 int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params)
  24 {
  25         int sample_size;
  26
  27         sample_size = snd_pcm_format_width(params_format(params));
  28         if (sample_size < 0)
  29                 return sample_size;
  30
  31         return snd_soc_calc_frame_size(sample_size, params_channels(params),
  32                                        1);
  33 }
  34 EXPORT_SYMBOL_GPL(snd_soc_params_to_frame_size);
  35
  36 int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots)
  37 {
  38         return fs * snd_soc_calc_frame_size(sample_size, channels, tdm_slots);
  39 }
  40 EXPORT_SYMBOL_GPL(snd_soc_calc_bclk);
  41
  42 int snd_soc_params_to_bclk(struct snd_pcm_hw_params *params)
  43 {
  44         int ret;
  45
  46         ret = snd_soc_params_to_frame_size(params);
  47
  48         if (ret > 0)
  49                 return ret * params_rate(params);
  50         else
  51                 return ret;
  52 }
  53 EXPORT_SYMBOL_GPL(snd_soc_params_to_bclk);
  54
  55 static const struct snd_pcm_hardware dummy_dma_hardware = {
  56         /* Random values to keep userspace happy when checking constraints */
  57         .info                   = SNDRV_PCM_INFO_INTERLEAVED |
  58                                   SNDRV_PCM_INFO_BLOCK_TRANSFER,
  59         .buffer_bytes_max       = 128*1024,
  60         .period_bytes_min       = PAGE_SIZE,
  61         .period_bytes_max       = PAGE_SIZE*2,
  62         .periods_min            = 2,
  63         .periods_max            = 128,
  64 };
  65
  66
  67 static const struct snd_soc_component_driver dummy_platform;
  68
  69 static int dummy_dma_open(struct snd_soc_component *component,
  70                           struct snd_pcm_substream *substream)
  71 {
  72         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
  73         int i;
  74
  75         /*
  76          * If there are other components associated with rtd, we shouldn't
  77          * override their hwparams
  78          */
  79         for_each_rtd_components(rtd, i, component) {
  80                 if (component->driver == &dummy_platform)
  81                         return 0;
  82         }
  83
  84         /* BE's dont need dummy params */
  85         if (!rtd->dai_link->no_pcm)
  86                 snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware);
  87
  88         return 0;
  89 }
  90
  91 static const struct snd_soc_component_driver dummy_platform = {
  92         .open           = dummy_dma_open,
  93 };
  94
  95 static const struct snd_soc_component_driver dummy_codec = {
  96         .idle_bias_on           = 1,
  97         .use_pmdown_time        = 1,
  98         .endianness             = 1,
  99         .non_legacy_dai_naming  = 1,
 100 };
 101
 102 #define STUB_RATES      SNDRV_PCM_RATE_8000_384000
 103 #define STUB_FORMATS    (SNDRV_PCM_FMTBIT_S8 | \
 104                         SNDRV_PCM_FMTBIT_U8 | \
 105                         SNDRV_PCM_FMTBIT_S16_LE | \
 106                         SNDRV_PCM_FMTBIT_U16_LE | \
 107                         SNDRV_PCM_FMTBIT_S24_LE | \
 108                         SNDRV_PCM_FMTBIT_S24_3LE | \
 109                         SNDRV_PCM_FMTBIT_U24_LE | \
 110                         SNDRV_PCM_FMTBIT_S32_LE | \
 111                         SNDRV_PCM_FMTBIT_U32_LE | \
 112                         SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
 113
 114 /*
 115  * Select these from Sound Card Manually
 116  *      SND_SOC_POSSIBLE_DAIFMT_CBP_CFP
 117  *      SND_SOC_POSSIBLE_DAIFMT_CBP_CFC
 118  *      SND_SOC_POSSIBLE_DAIFMT_CBC_CFP
 119  *      SND_SOC_POSSIBLE_DAIFMT_CBC_CFC
 120  */
 121 static u64 dummy_dai_formats =
 122         SND_SOC_POSSIBLE_DAIFMT_I2S     |
 123         SND_SOC_POSSIBLE_DAIFMT_RIGHT_J |
 124         SND_SOC_POSSIBLE_DAIFMT_LEFT_J  |
 125         SND_SOC_POSSIBLE_DAIFMT_DSP_A   |
 126         SND_SOC_POSSIBLE_DAIFMT_DSP_B   |
 127         SND_SOC_POSSIBLE_DAIFMT_AC97    |
 128         SND_SOC_POSSIBLE_DAIFMT_PDM     |
 129         SND_SOC_POSSIBLE_DAIFMT_GATED   |
 130         SND_SOC_POSSIBLE_DAIFMT_CONT    |
 131         SND_SOC_POSSIBLE_DAIFMT_NB_NF   |
 132         SND_SOC_POSSIBLE_DAIFMT_NB_IF   |
 133         SND_SOC_POSSIBLE_DAIFMT_IB_NF   |
 134         SND_SOC_POSSIBLE_DAIFMT_IB_IF;
 135
 136 static const struct snd_soc_dai_ops dummy_dai_ops = {
 137         .auto_selectable_formats        = &dummy_dai_formats,
 138         .num_auto_selectable_formats    = 1,
 139 };
 140
 141 /*
 142  * The dummy CODEC is only meant to be used in situations where there is no
 143  * actual hardware.
 144  *
 145  * If there is actual hardware even if it does not have a control bus
 146  * the hardware will still have constraints like supported samplerates, etc.
 147  * which should be modelled. And the data flow graph also should be modelled
 148  * using DAPM.
 149  */
 150 static struct snd_soc_dai_driver dummy_dai = {
 151         .name = "snd-soc-dummy-dai",
 152         .playback = {
 153                 .stream_name    = "Playback",
 154                 .channels_min   = 1,
 155                 .channels_max   = 384,
 156                 .rates          = STUB_RATES,
 157                 .formats        = STUB_FORMATS,
 158         },
 159         .capture = {
 160                 .stream_name    = "Capture",
 161                 .channels_min   = 1,
 162                 .channels_max   = 384,
 163                 .rates = STUB_RATES,
 164                 .formats = STUB_FORMATS,
 165          },
 166         .ops = &dummy_dai_ops,
 167 };
 168
 169 int snd_soc_dai_is_dummy(struct snd_soc_dai *dai)
 170 {
 171         if (dai->driver == &dummy_dai)
 172                 return 1;
 173         return 0;
 174 }
 175
 176 int snd_soc_component_is_dummy(struct snd_soc_component *component)
 177 {
 178         return ((component->driver == &dummy_platform) ||
 179                 (component->driver == &dummy_codec));
 180 }
 181
 182 static int snd_soc_dummy_probe(struct platform_device *pdev)
 183 {
 184         int ret;
 185
 186         ret = devm_snd_soc_register_component(&pdev->dev,
 187                                               &dummy_codec, &dummy_dai, 1);
 188         if (ret < 0)
 189                 return ret;
 190
 191         ret = devm_snd_soc_register_component(&pdev->dev, &dummy_platform,
 192                                               NULL, 0);
 193
 194         return ret;
 195 }
 196
 197 static struct platform_driver soc_dummy_driver = {
 198         .driver = {
 199                 .name = "snd-soc-dummy",
 200         },
 201         .probe = snd_soc_dummy_probe,
 202 };
 203
 204 static struct platform_device *soc_dummy_dev;
 205
 206 int __init snd_soc_util_init(void)
 207 {
 208         int ret;
 209
 210         soc_dummy_dev =
 211                 platform_device_register_simple("snd-soc-dummy", -1, NULL, 0);
 212         if (IS_ERR(soc_dummy_dev))
 213                 return PTR_ERR(soc_dummy_dev);
 214
 215         ret = platform_driver_register(&soc_dummy_driver);
 216         if (ret != 0)
 217                 platform_device_unregister(soc_dummy_dev);
 218
 219         return ret;
 220 }
 221
 222 void __exit snd_soc_util_exit(void)
 223 {
 224         platform_driver_unregister(&soc_dummy_driver);
 225         platform_device_unregister(soc_dummy_dev);
 226 }