sound/soc/meson/axg-tdm-interface.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2 //
   3 // Copyright (c) 2018 BayLibre, SAS.
   4 // Author: Jerome Brunet <jbrunet@baylibre.com>
   5
   6 #include <linux/clk.h>
   7 #include <linux/module.h>
   8 #include <linux/of_platform.h>
   9 #include <sound/pcm_params.h>
  10 #include <sound/soc.h>
  11 #include <sound/soc-dai.h>
  12
  13 #include "axg-tdm.h"
  14
  15 enum {
  16         TDM_IFACE_PAD,
  17         TDM_IFACE_LOOPBACK,
  18 };
  19
  20 static unsigned int axg_tdm_slots_total(u32 *mask)
  21 {
  22         unsigned int slots = 0;
  23         int i;
  24
  25         if (!mask)
  26                 return 0;
  27
  28         /* Count the total number of slots provided by all 4 lanes */
  29         for (i = 0; i < AXG_TDM_NUM_LANES; i++)
  30                 slots += hweight32(mask[i]);
  31
  32         return slots;
  33 }
  34
  35 int axg_tdm_set_tdm_slots(struct snd_soc_dai *dai, u32 *tx_mask,
  36                           u32 *rx_mask, unsigned int slots,
  37                           unsigned int slot_width)
  38 {
  39         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
  40         struct axg_tdm_stream *tx = (struct axg_tdm_stream *)
  41                 dai->playback_dma_data;
  42         struct axg_tdm_stream *rx = (struct axg_tdm_stream *)
  43                 dai->capture_dma_data;
  44         unsigned int tx_slots, rx_slots;
  45
  46         tx_slots = axg_tdm_slots_total(tx_mask);
  47         rx_slots = axg_tdm_slots_total(rx_mask);
  48
  49         /* We should at least have a slot for a valid interface */
  50         if (!tx_slots && !rx_slots) {
  51                 dev_err(dai->dev, "interface has no slot\n");
  52                 return -EINVAL;
  53         }
  54
  55         /*
  56          * Amend the dai driver channel number and let dpcm channel merge do
  57          * its job
  58          */
  59         if (tx) {
  60                 tx->mask = tx_mask;
  61                 dai->driver->playback.channels_max = tx_slots;
  62         }
  63
  64         if (rx) {
  65                 rx->mask = rx_mask;
  66                 dai->driver->capture.channels_max = rx_slots;
  67         }
  68
  69         iface->slots = slots;
  70
  71         switch (slot_width) {
  72         case 0:
  73                 /* defaults width to 32 if not provided */
  74                 iface->slot_width = 32;
  75                 break;
  76         case 8:
  77         case 16:
  78         case 24:
  79         case 32:
  80                 iface->slot_width = slot_width;
  81                 break;
  82         default:
  83                 dev_err(dai->dev, "unsupported slot width: %d\n", slot_width);
  84                 return -EINVAL;
  85         }
  86
  87         return 0;
  88 }
  89 EXPORT_SYMBOL_GPL(axg_tdm_set_tdm_slots);
  90
  91 static int axg_tdm_iface_set_sysclk(struct snd_soc_dai *dai, int clk_id,
  92                                     unsigned int freq, int dir)
  93 {
  94         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
  95         int ret = -ENOTSUPP;
  96
  97         if (dir == SND_SOC_CLOCK_OUT && clk_id == 0) {
  98                 if (!iface->mclk) {
  99                         dev_warn(dai->dev, "master clock not provided\n");
 100                 } else {
 101                         ret = clk_set_rate(iface->mclk, freq);
 102                         if (!ret)
 103                                 iface->mclk_rate = freq;
 104                 }
 105         }
 106
 107         return ret;
 108 }
 109
 110 static int axg_tdm_iface_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 111 {
 112         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
 113
 114         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 115         case SND_SOC_DAIFMT_CBS_CFS:
 116                 if (!iface->mclk) {
 117                         dev_err(dai->dev, "cpu clock master: mclk missing\n");
 118                         return -ENODEV;
 119                 }
 120                 break;
 121
 122         case SND_SOC_DAIFMT_CBM_CFM:
 123                 break;
 124
 125         case SND_SOC_DAIFMT_CBS_CFM:
 126         case SND_SOC_DAIFMT_CBM_CFS:
 127                 dev_err(dai->dev, "only CBS_CFS and CBM_CFM are supported\n");
 128                 /* Fall-through */
 129         default:
 130                 return -EINVAL;
 131         }
 132
 133         iface->fmt = fmt;
 134         return 0;
 135 }
 136
 137 static int axg_tdm_iface_startup(struct snd_pcm_substream *substream,
 138                                  struct snd_soc_dai *dai)
 139 {
 140         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
 141         struct axg_tdm_stream *ts =
 142                 snd_soc_dai_get_dma_data(dai, substream);
 143         int ret;
 144
 145         if (!axg_tdm_slots_total(ts->mask)) {
 146                 dev_err(dai->dev, "interface has not slots\n");
 147                 return -EINVAL;
 148         }
 149
 150         /* Apply component wide rate symmetry */
 151         if (dai->component->active) {
 152                 ret = snd_pcm_hw_constraint_single(substream->runtime,
 153                                                    SNDRV_PCM_HW_PARAM_RATE,
 154                                                    iface->rate);
 155                 if (ret < 0) {
 156                         dev_err(dai->dev,
 157                                 "can't set iface rate constraint\n");
 158                         return ret;
 159                 }
 160         }
 161
 162         return 0;
 163 }
 164
 165 static int axg_tdm_iface_set_stream(struct snd_pcm_substream *substream,
 166                                     struct snd_pcm_hw_params *params,
 167                                     struct snd_soc_dai *dai)
 168 {
 169         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
 170         struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
 171         unsigned int channels = params_channels(params);
 172         unsigned int width = params_width(params);
 173
 174         /* Save rate and sample_bits for component symmetry */
 175         iface->rate = params_rate(params);
 176
 177         /* Make sure this interface can cope with the stream */
 178         if (axg_tdm_slots_total(ts->mask) < channels) {
 179                 dev_err(dai->dev, "not enough slots for channels\n");
 180                 return -EINVAL;
 181         }
 182
 183         if (iface->slot_width < width) {
 184                 dev_err(dai->dev, "incompatible slots width for stream\n");
 185                 return -EINVAL;
 186         }
 187
 188         /* Save the parameter for tdmout/tdmin widgets */
 189         ts->physical_width = params_physical_width(params);
 190         ts->width = params_width(params);
 191         ts->channels = params_channels(params);
 192
 193         return 0;
 194 }
 195
 196 static int axg_tdm_iface_set_lrclk(struct snd_soc_dai *dai,
 197                                    struct snd_pcm_hw_params *params)
 198 {
 199         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
 200         unsigned int ratio_num;
 201         int ret;
 202
 203         ret = clk_set_rate(iface->lrclk, params_rate(params));
 204         if (ret) {
 205                 dev_err(dai->dev, "setting sample clock failed: %d\n", ret);
 206                 return ret;
 207         }
 208
 209         switch (iface->fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 210         case SND_SOC_DAIFMT_I2S:
 211         case SND_SOC_DAIFMT_LEFT_J:
 212         case SND_SOC_DAIFMT_RIGHT_J:
 213                 /* 50% duty cycle ratio */
 214                 ratio_num = 1;
 215                 break;
 216
 217         case SND_SOC_DAIFMT_DSP_A:
 218         case SND_SOC_DAIFMT_DSP_B:
 219                 /*
 220                  * A zero duty cycle ratio will result in setting the mininum
 221                  * ratio possible which, for this clock, is 1 cycle of the
 222                  * parent bclk clock high and the rest low, This is exactly
 223                  * what we want here.
 224                  */
 225                 ratio_num = 0;
 226                 break;
 227
 228         default:
 229                 return -EINVAL;
 230         }
 231
 232         ret = clk_set_duty_cycle(iface->lrclk, ratio_num, 2);
 233         if (ret) {
 234                 dev_err(dai->dev,
 235                         "setting sample clock duty cycle failed: %d\n", ret);
 236                 return ret;
 237         }
 238
 239         /* Set sample clock inversion */
 240         ret = clk_set_phase(iface->lrclk,
 241                             axg_tdm_lrclk_invert(iface->fmt) ? 180 : 0);
 242         if (ret) {
 243                 dev_err(dai->dev,
 244                         "setting sample clock phase failed: %d\n", ret);
 245                 return ret;
 246         }
 247
 248         return 0;
 249 }
 250
 251 static int axg_tdm_iface_set_sclk(struct snd_soc_dai *dai,
 252                                   struct snd_pcm_hw_params *params)
 253 {
 254         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
 255         unsigned long srate;
 256         int ret;
 257
 258         srate = iface->slots * iface->slot_width * params_rate(params);
 259
 260         if (!iface->mclk_rate) {
 261                 /* If no specific mclk is requested, default to bit clock * 4 */
 262                 clk_set_rate(iface->mclk, 4 * srate);
 263         } else {
 264                 /* Check if we can actually get the bit clock from mclk */
 265                 if (iface->mclk_rate % srate) {
 266                         dev_err(dai->dev,
 267                                 "can't derive sclk %lu from mclk %lu\n",
 268                                 srate, iface->mclk_rate);
 269                         return -EINVAL;
 270                 }
 271         }
 272
 273         ret = clk_set_rate(iface->sclk, srate);
 274         if (ret) {
 275                 dev_err(dai->dev, "setting bit clock failed: %d\n", ret);
 276                 return ret;
 277         }
 278
 279         /* Set the bit clock inversion */
 280         ret = clk_set_phase(iface->sclk,
 281                             axg_tdm_sclk_invert(iface->fmt) ? 0 : 180);
 282         if (ret) {
 283                 dev_err(dai->dev, "setting bit clock phase failed: %d\n", ret);
 284                 return ret;
 285         }
 286
 287         return ret;
 288 }
 289
 290 static int axg_tdm_iface_hw_params(struct snd_pcm_substream *substream,
 291                                    struct snd_pcm_hw_params *params,
 292                                    struct snd_soc_dai *dai)
 293 {
 294         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
 295         int ret;
 296
 297         switch (iface->fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 298         case SND_SOC_DAIFMT_I2S:
 299         case SND_SOC_DAIFMT_LEFT_J:
 300         case SND_SOC_DAIFMT_RIGHT_J:
 301                 if (iface->slots > 2) {
 302                         dev_err(dai->dev, "bad slot number for format: %d\n",
 303                                 iface->slots);
 304                         return -EINVAL;
 305                 }
 306                 break;
 307
 308         case SND_SOC_DAI_FORMAT_DSP_A:
 309         case SND_SOC_DAI_FORMAT_DSP_B:
 310                 break;
 311
 312         default:
 313                 dev_err(dai->dev, "unsupported dai format\n");
 314                 return -EINVAL;
 315         }
 316
 317         ret = axg_tdm_iface_set_stream(substream, params, dai);
 318         if (ret)
 319                 return ret;
 320
 321         if ((iface->fmt & SND_SOC_DAIFMT_MASTER_MASK) ==
 322             SND_SOC_DAIFMT_CBS_CFS) {
 323                 ret = axg_tdm_iface_set_sclk(dai, params);
 324                 if (ret)
 325                         return ret;
 326
 327                 ret = axg_tdm_iface_set_lrclk(dai, params);
 328                 if (ret)
 329                         return ret;
 330         }
 331
 332         return 0;
 333 }
 334
 335 static int axg_tdm_iface_hw_free(struct snd_pcm_substream *substream,
 336                                  struct snd_soc_dai *dai)
 337 {
 338         struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
 339
 340         /* Stop all attached formatters */
 341         axg_tdm_stream_stop(ts);
 342
 343         return 0;
 344 }
 345
 346 static int axg_tdm_iface_prepare(struct snd_pcm_substream *substream,
 347                                  struct snd_soc_dai *dai)
 348 {
 349         struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
 350
 351         /* Force all attached formatters to update */
 352         return axg_tdm_stream_reset(ts);
 353 }
 354
 355 static int axg_tdm_iface_remove_dai(struct snd_soc_dai *dai)
 356 {
 357         if (dai->capture_dma_data)
 358                 axg_tdm_stream_free(dai->capture_dma_data);
 359
 360         if (dai->playback_dma_data)
 361                 axg_tdm_stream_free(dai->playback_dma_data);
 362
 363         return 0;
 364 }
 365
 366 static int axg_tdm_iface_probe_dai(struct snd_soc_dai *dai)
 367 {
 368         struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
 369
 370         if (dai->capture_widget) {
 371                 dai->capture_dma_data = axg_tdm_stream_alloc(iface);
 372                 if (!dai->capture_dma_data)
 373                         return -ENOMEM;
 374         }
 375
 376         if (dai->playback_widget) {
 377                 dai->playback_dma_data = axg_tdm_stream_alloc(iface);
 378                 if (!dai->playback_dma_data) {
 379                         axg_tdm_iface_remove_dai(dai);
 380                         return -ENOMEM;
 381                 }
 382         }
 383
 384         return 0;
 385 }
 386
 387 static const struct snd_soc_dai_ops axg_tdm_iface_ops = {
 388         .set_sysclk     = axg_tdm_iface_set_sysclk,
 389         .set_fmt        = axg_tdm_iface_set_fmt,
 390         .startup        = axg_tdm_iface_startup,
 391         .hw_params      = axg_tdm_iface_hw_params,
 392         .prepare        = axg_tdm_iface_prepare,
 393         .hw_free        = axg_tdm_iface_hw_free,
 394 };
 395
 396 /* TDM Backend DAIs */
 397 static const struct snd_soc_dai_driver axg_tdm_iface_dai_drv[] = {
 398         [TDM_IFACE_PAD] = {
 399                 .name = "TDM Pad",
 400                 .playback = {
 401                         .stream_name    = "Playback",
 402                         .channels_min   = 1,
 403                         .channels_max   = AXG_TDM_CHANNEL_MAX,
 404                         .rates          = AXG_TDM_RATES,
 405                         .formats        = AXG_TDM_FORMATS,
 406                 },
 407                 .capture = {
 408                         .stream_name    = "Capture",
 409                         .channels_min   = 1,
 410                         .channels_max   = AXG_TDM_CHANNEL_MAX,
 411                         .rates          = AXG_TDM_RATES,
 412                         .formats        = AXG_TDM_FORMATS,
 413                 },
 414                 .id = TDM_IFACE_PAD,
 415                 .ops = &axg_tdm_iface_ops,
 416                 .probe = axg_tdm_iface_probe_dai,
 417                 .remove = axg_tdm_iface_remove_dai,
 418         },
 419         [TDM_IFACE_LOOPBACK] = {
 420                 .name = "TDM Loopback",
 421                 .capture = {
 422                         .stream_name    = "Loopback",
 423                         .channels_min   = 1,
 424                         .channels_max   = AXG_TDM_CHANNEL_MAX,
 425                         .rates          = AXG_TDM_RATES,
 426                         .formats        = AXG_TDM_FORMATS,
 427                 },
 428                 .id = TDM_IFACE_LOOPBACK,
 429                 .ops = &axg_tdm_iface_ops,
 430                 .probe = axg_tdm_iface_probe_dai,
 431                 .remove = axg_tdm_iface_remove_dai,
 432         },
 433 };
 434
 435 static int axg_tdm_iface_set_bias_level(struct snd_soc_component *component,
 436                                         enum snd_soc_bias_level level)
 437 {
 438         struct axg_tdm_iface *iface = snd_soc_component_get_drvdata(component);
 439         enum snd_soc_bias_level now =
 440                 snd_soc_component_get_bias_level(component);
 441         int ret = 0;
 442
 443         switch (level) {
 444         case SND_SOC_BIAS_PREPARE:
 445                 if (now == SND_SOC_BIAS_STANDBY)
 446                         ret = clk_prepare_enable(iface->mclk);
 447                 break;
 448
 449         case SND_SOC_BIAS_STANDBY:
 450                 if (now == SND_SOC_BIAS_PREPARE)
 451                         clk_disable_unprepare(iface->mclk);
 452                 break;
 453
 454         case SND_SOC_BIAS_OFF:
 455         case SND_SOC_BIAS_ON:
 456                 break;
 457         }
 458
 459         return ret;
 460 }
 461
 462 static const struct snd_soc_dapm_widget axg_tdm_iface_dapm_widgets[] = {
 463         SND_SOC_DAPM_SIGGEN("Playback Signal"),
 464 };
 465
 466 static const struct snd_soc_dapm_route axg_tdm_iface_dapm_routes[] = {
 467         { "Loopback", NULL, "Playback Signal" },
 468 };
 469
 470 static const struct snd_soc_component_driver axg_tdm_iface_component_drv = {
 471         .dapm_widgets           = axg_tdm_iface_dapm_widgets,
 472         .num_dapm_widgets       = ARRAY_SIZE(axg_tdm_iface_dapm_widgets),
 473         .dapm_routes            = axg_tdm_iface_dapm_routes,
 474         .num_dapm_routes        = ARRAY_SIZE(axg_tdm_iface_dapm_routes),
 475         .set_bias_level         = axg_tdm_iface_set_bias_level,
 476 };
 477
 478 static const struct of_device_id axg_tdm_iface_of_match[] = {
 479         { .compatible = "amlogic,axg-tdm-iface", },
 480         {}
 481 };
 482 MODULE_DEVICE_TABLE(of, axg_tdm_iface_of_match);
 483
 484 static int axg_tdm_iface_probe(struct platform_device *pdev)
 485 {
 486         struct device *dev = &pdev->dev;
 487         struct snd_soc_dai_driver *dai_drv;
 488         struct axg_tdm_iface *iface;
 489         int ret, i;
 490
 491         iface = devm_kzalloc(dev, sizeof(*iface), GFP_KERNEL);
 492         if (!iface)
 493                 return -ENOMEM;
 494         platform_set_drvdata(pdev, iface);
 495
 496         /*
 497          * Duplicate dai driver: depending on the slot masks configuration
 498          * We'll change the number of channel provided by DAI stream, so dpcm
 499          * channel merge can be done properly
 500          */
 501         dai_drv = devm_kcalloc(dev, ARRAY_SIZE(axg_tdm_iface_dai_drv),
 502                                sizeof(*dai_drv), GFP_KERNEL);
 503         if (!dai_drv)
 504                 return -ENOMEM;
 505
 506         for (i = 0; i < ARRAY_SIZE(axg_tdm_iface_dai_drv); i++)
 507                 memcpy(&dai_drv[i], &axg_tdm_iface_dai_drv[i],
 508                        sizeof(*dai_drv));
 509
 510         /* Bit clock provided on the pad */
 511         iface->sclk = devm_clk_get(dev, "sclk");
 512         if (IS_ERR(iface->sclk)) {
 513                 ret = PTR_ERR(iface->sclk);
 514                 if (ret != -EPROBE_DEFER)
 515                         dev_err(dev, "failed to get sclk: %d\n", ret);
 516                 return ret;
 517         }
 518
 519         /* Sample clock provided on the pad */
 520         iface->lrclk = devm_clk_get(dev, "lrclk");
 521         if (IS_ERR(iface->lrclk)) {
 522                 ret = PTR_ERR(iface->lrclk);
 523                 if (ret != -EPROBE_DEFER)
 524                         dev_err(dev, "failed to get lrclk: %d\n", ret);
 525                 return ret;
 526         }
 527
 528         /*
 529          * mclk maybe be missing when the cpu dai is in slave mode and
 530          * the codec does not require it to provide a master clock.
 531          * At this point, ignore the error if mclk is missing. We'll
 532          * throw an error if the cpu dai is master and mclk is missing
 533          */
 534         iface->mclk = devm_clk_get(dev, "mclk");
 535         if (IS_ERR(iface->mclk)) {
 536                 ret = PTR_ERR(iface->mclk);
 537                 if (ret == -ENOENT) {
 538                         iface->mclk = NULL;
 539                 } else {
 540                         if (ret != -EPROBE_DEFER)
 541                                 dev_err(dev, "failed to get mclk: %d\n", ret);
 542                         return ret;
 543                 }
 544         }
 545
 546         return devm_snd_soc_register_component(dev,
 547                                         &axg_tdm_iface_component_drv, dai_drv,
 548                                         ARRAY_SIZE(axg_tdm_iface_dai_drv));
 549 }
 550
 551 static struct platform_driver axg_tdm_iface_pdrv = {
 552         .probe = axg_tdm_iface_probe,
 553         .driver = {
 554                 .name = "axg-tdm-iface",
 555                 .of_match_table = axg_tdm_iface_of_match,
 556         },
 557 };
 558 module_platform_driver(axg_tdm_iface_pdrv);
 559
 560 MODULE_DESCRIPTION("Amlogic AXG TDM interface driver");
 561 MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
 562 MODULE_LICENSE("GPL v2");