sound/soc/soc-dai.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // soc-dai.c
   4 //
   5 // Copyright (C) 2019 Renesas Electronics Corp.
   6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   7 //
   8
   9 #include <sound/soc.h>
  10 #include <sound/soc-dai.h>
  11
  12 /**
  13  * snd_soc_dai_set_sysclk - configure DAI system or master clock.
  14  * @dai: DAI
  15  * @clk_id: DAI specific clock ID
  16  * @freq: new clock frequency in Hz
  17  * @dir: new clock direction - input/output.
  18  *
  19  * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
  20  */
  21 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
  22                            unsigned int freq, int dir)
  23 {
  24         if (dai->driver->ops->set_sysclk)
  25                 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
  26
  27         return snd_soc_component_set_sysclk(dai->component, clk_id, 0,
  28                                             freq, dir);
  29 }
  30 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
  31
  32 /**
  33  * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
  34  * @dai: DAI
  35  * @div_id: DAI specific clock divider ID
  36  * @div: new clock divisor.
  37  *
  38  * Configures the clock dividers. This is used to derive the best DAI bit and
  39  * frame clocks from the system or master clock. It's best to set the DAI bit
  40  * and frame clocks as low as possible to save system power.
  41  */
  42 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
  43                            int div_id, int div)
  44 {
  45         if (dai->driver->ops->set_clkdiv)
  46                 return dai->driver->ops->set_clkdiv(dai, div_id, div);
  47         else
  48                 return -EINVAL;
  49 }
  50 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
  51
  52 /**
  53  * snd_soc_dai_set_pll - configure DAI PLL.
  54  * @dai: DAI
  55  * @pll_id: DAI specific PLL ID
  56  * @source: DAI specific source for the PLL
  57  * @freq_in: PLL input clock frequency in Hz
  58  * @freq_out: requested PLL output clock frequency in Hz
  59  *
  60  * Configures and enables PLL to generate output clock based on input clock.
  61  */
  62 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
  63                         unsigned int freq_in, unsigned int freq_out)
  64 {
  65         if (dai->driver->ops->set_pll)
  66                 return dai->driver->ops->set_pll(dai, pll_id, source,
  67                                                  freq_in, freq_out);
  68
  69         return snd_soc_component_set_pll(dai->component, pll_id, source,
  70                                          freq_in, freq_out);
  71 }
  72 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
  73
  74 /**
  75  * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
  76  * @dai: DAI
  77  * @ratio: Ratio of BCLK to Sample rate.
  78  *
  79  * Configures the DAI for a preset BCLK to sample rate ratio.
  80  */
  81 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
  82 {
  83         if (dai->driver->ops->set_bclk_ratio)
  84                 return dai->driver->ops->set_bclk_ratio(dai, ratio);
  85         else
  86                 return -EINVAL;
  87 }
  88 EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
  89
  90 /**
  91  * snd_soc_dai_set_fmt - configure DAI hardware audio format.
  92  * @dai: DAI
  93  * @fmt: SND_SOC_DAIFMT_* format value.
  94  *
  95  * Configures the DAI hardware format and clocking.
  96  */
  97 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
  98 {
  99         if (dai->driver->ops->set_fmt == NULL)
 100                 return -ENOTSUPP;
 101         return dai->driver->ops->set_fmt(dai, fmt);
 102 }
 103 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
 104
 105 /**
 106  * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
 107  * @slots: Number of slots in use.
 108  * @tx_mask: bitmask representing active TX slots.
 109  * @rx_mask: bitmask representing active RX slots.
 110  *
 111  * Generates the TDM tx and rx slot default masks for DAI.
 112  */
 113 static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
 114                                        unsigned int *tx_mask,
 115                                        unsigned int *rx_mask)
 116 {
 117         if (*tx_mask || *rx_mask)
 118                 return 0;
 119
 120         if (!slots)
 121                 return -EINVAL;
 122
 123         *tx_mask = (1 << slots) - 1;
 124         *rx_mask = (1 << slots) - 1;
 125
 126         return 0;
 127 }
 128
 129 /**
 130  * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
 131  * @dai: The DAI to configure
 132  * @tx_mask: bitmask representing active TX slots.
 133  * @rx_mask: bitmask representing active RX slots.
 134  * @slots: Number of slots in use.
 135  * @slot_width: Width in bits for each slot.
 136  *
 137  * This function configures the specified DAI for TDM operation. @slot contains
 138  * the total number of slots of the TDM stream and @slot_with the width of each
 139  * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
 140  * active slots of the TDM stream for the specified DAI, i.e. which slots the
 141  * DAI should write to or read from. If a bit is set the corresponding slot is
 142  * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
 143  * the first slot, bit 1 to the second slot and so on. The first active slot
 144  * maps to the first channel of the DAI, the second active slot to the second
 145  * channel and so on.
 146  *
 147  * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
 148  * @rx_mask and @slot_width will be ignored.
 149  *
 150  * Returns 0 on success, a negative error code otherwise.
 151  */
 152 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
 153                              unsigned int tx_mask, unsigned int rx_mask,
 154                              int slots, int slot_width)
 155 {
 156         if (dai->driver->ops->xlate_tdm_slot_mask)
 157                 dai->driver->ops->xlate_tdm_slot_mask(slots,
 158                                                       &tx_mask, &rx_mask);
 159         else
 160                 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
 161
 162         dai->tx_mask = tx_mask;
 163         dai->rx_mask = rx_mask;
 164
 165         if (dai->driver->ops->set_tdm_slot)
 166                 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
 167                                                       slots, slot_width);
 168         else
 169                 return -ENOTSUPP;
 170 }
 171 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
 172
 173 /**
 174  * snd_soc_dai_set_channel_map - configure DAI audio channel map
 175  * @dai: DAI
 176  * @tx_num: how many TX channels
 177  * @tx_slot: pointer to an array which imply the TX slot number channel
 178  *           0~num-1 uses
 179  * @rx_num: how many RX channels
 180  * @rx_slot: pointer to an array which imply the RX slot number channel
 181  *           0~num-1 uses
 182  *
 183  * configure the relationship between channel number and TDM slot number.
 184  */
 185 int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
 186                                 unsigned int tx_num, unsigned int *tx_slot,
 187                                 unsigned int rx_num, unsigned int *rx_slot)
 188 {
 189         if (dai->driver->ops->set_channel_map)
 190                 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
 191                                                          rx_num, rx_slot);
 192         else
 193                 return -ENOTSUPP;
 194 }
 195 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
 196
 197 /**
 198  * snd_soc_dai_get_channel_map - Get DAI audio channel map
 199  * @dai: DAI
 200  * @tx_num: how many TX channels
 201  * @tx_slot: pointer to an array which imply the TX slot number channel
 202  *           0~num-1 uses
 203  * @rx_num: how many RX channels
 204  * @rx_slot: pointer to an array which imply the RX slot number channel
 205  *           0~num-1 uses
 206  */
 207 int snd_soc_dai_get_channel_map(struct snd_soc_dai *dai,
 208                                 unsigned int *tx_num, unsigned int *tx_slot,
 209                                 unsigned int *rx_num, unsigned int *rx_slot)
 210 {
 211         if (dai->driver->ops->get_channel_map)
 212                 return dai->driver->ops->get_channel_map(dai, tx_num, tx_slot,
 213                                                          rx_num, rx_slot);
 214         else
 215                 return -ENOTSUPP;
 216 }
 217 EXPORT_SYMBOL_GPL(snd_soc_dai_get_channel_map);
 218
 219 /**
 220  * snd_soc_dai_set_tristate - configure DAI system or master clock.
 221  * @dai: DAI
 222  * @tristate: tristate enable
 223  *
 224  * Tristates the DAI so that others can use it.
 225  */
 226 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
 227 {
 228         if (dai->driver->ops->set_tristate)
 229                 return dai->driver->ops->set_tristate(dai, tristate);
 230         else
 231                 return -EINVAL;
 232 }
 233 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
 234
 235 /**
 236  * snd_soc_dai_digital_mute - configure DAI system or master clock.
 237  * @dai: DAI
 238  * @mute: mute enable
 239  * @direction: stream to mute
 240  *
 241  * Mutes the DAI DAC.
 242  */
 243 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
 244                              int direction)
 245 {
 246         if (dai->driver->ops->mute_stream)
 247                 return dai->driver->ops->mute_stream(dai, mute, direction);
 248         else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
 249                  dai->driver->ops->digital_mute)
 250                 return dai->driver->ops->digital_mute(dai, mute);
 251         else
 252                 return -ENOTSUPP;
 253 }
 254 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
 255
 256 int snd_soc_dai_hw_params(struct snd_soc_dai *dai,
 257                           struct snd_pcm_substream *substream,
 258                           struct snd_pcm_hw_params *params)
 259 {
 260         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 261         int ret;
 262
 263         /* perform any topology hw_params fixups before DAI  */
 264         if (rtd->dai_link->be_hw_params_fixup) {
 265                 ret = rtd->dai_link->be_hw_params_fixup(rtd, params);
 266                 if (ret < 0) {
 267                         dev_err(rtd->dev,
 268                                 "ASoC: hw_params topology fixup failed %d\n",
 269                                 ret);
 270                         return ret;
 271                 }
 272         }
 273
 274         if (dai->driver->ops->hw_params) {
 275                 ret = dai->driver->ops->hw_params(substream, params, dai);
 276                 if (ret < 0) {
 277                         dev_err(dai->dev, "ASoC: can't set %s hw params: %d\n",
 278                                 dai->name, ret);
 279                         return ret;
 280                 }
 281         }
 282
 283         return 0;
 284 }
 285
 286 void snd_soc_dai_hw_free(struct snd_soc_dai *dai,
 287                          struct snd_pcm_substream *substream)
 288 {
 289         if (dai->driver->ops->hw_free)
 290                 dai->driver->ops->hw_free(substream, dai);
 291 }
 292
 293 int snd_soc_dai_startup(struct snd_soc_dai *dai,
 294                         struct snd_pcm_substream *substream)
 295 {
 296         int ret = 0;
 297
 298         if (dai->driver->ops->startup)
 299                 ret = dai->driver->ops->startup(substream, dai);
 300
 301         return ret;
 302 }
 303
 304 void snd_soc_dai_shutdown(struct snd_soc_dai *dai,
 305                          struct snd_pcm_substream *substream)
 306 {
 307         if (dai->driver->ops->shutdown)
 308                 dai->driver->ops->shutdown(substream, dai);
 309 }
 310
 311 int snd_soc_dai_prepare(struct snd_soc_dai *dai,
 312                         struct snd_pcm_substream *substream)
 313 {
 314         int ret = 0;
 315
 316         if (dai->driver->ops->prepare)
 317                 ret = dai->driver->ops->prepare(substream, dai);
 318
 319         return ret;
 320 }
 321
 322 int snd_soc_dai_trigger(struct snd_soc_dai *dai,
 323                         struct snd_pcm_substream *substream,
 324                         int cmd)
 325 {
 326         int ret = 0;
 327
 328         if (dai->driver->ops->trigger)
 329                 ret = dai->driver->ops->trigger(substream, cmd, dai);
 330
 331         return ret;
 332 }
 333
 334 int snd_soc_dai_bespoke_trigger(struct snd_soc_dai *dai,
 335                                 struct snd_pcm_substream *substream,
 336                                 int cmd)
 337 {
 338         int ret = 0;
 339
 340         if (dai->driver->ops->bespoke_trigger)
 341                 ret = dai->driver->ops->bespoke_trigger(substream, cmd, dai);
 342
 343         return ret;
 344 }
 345
 346 snd_pcm_sframes_t snd_soc_dai_delay(struct snd_soc_dai *dai,
 347                                     struct snd_pcm_substream *substream)
 348 {
 349         int delay = 0;
 350
 351         if (dai->driver->ops->delay)
 352                 delay = dai->driver->ops->delay(substream, dai);
 353
 354         return delay;
 355 }
 356
 357 int snd_soc_dai_probe(struct snd_soc_dai *dai)
 358 {
 359         if (dai->driver->probe)
 360                 return dai->driver->probe(dai);
 361         return 0;
 362 }
 363
 364 int snd_soc_dai_remove(struct snd_soc_dai *dai)
 365 {
 366         if (dai->driver->remove)
 367                 return dai->driver->remove(dai);
 368         return 0;
 369 }
 370
 371 int snd_soc_dai_compress_new(struct snd_soc_dai *dai,
 372                              struct snd_soc_pcm_runtime *rtd, int num)
 373 {
 374         if (dai->driver->compress_new)
 375                 return dai->driver->compress_new(rtd, num);
 376         return -ENOTSUPP;
 377 }
 378
 379 /*
 380  * snd_soc_dai_stream_valid() - check if a DAI supports the given stream
 381  *
 382  * Returns true if the DAI supports the indicated stream type.
 383  */
 384 bool snd_soc_dai_stream_valid(struct snd_soc_dai *dai, int dir)
 385 {
 386         struct snd_soc_pcm_stream *stream;
 387
 388         if (dir == SNDRV_PCM_STREAM_PLAYBACK)
 389                 stream = &dai->driver->playback;
 390         else
 391                 stream = &dai->driver->capture;
 392
 393         /* If the codec specifies any channels at all, it supports the stream */
 394         return stream->channels_min;
 395 }