sound/soc/starfive/starfive_spdif.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * SPDIF driver for the StarFive JH7110 SoC
   4  *
   5  * Copyright (C) 2022 StarFive Technology Co., Ltd.
   6  */
   7
   8 #include <linux/init.h>
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/slab.h>
  13 #include <linux/of.h>
  14 #include <linux/clk.h>
  15 #include <linux/regmap.h>
  16 #include <linux/reset.h>
  17
  18 #include <sound/core.h>
  19 #include <sound/pcm.h>
  20 #include <sound/pcm_params.h>
  21 #include <sound/soc.h>
  22 #include <sound/initval.h>
  23 #include <sound/dmaengine_pcm.h>
  24 #include "starfive_spdif.h"
  25
  26 static irqreturn_t spdif_irq_handler(int irq, void *dev_id)
  27 {
  28         struct sf_spdif_dev *dev = dev_id;
  29         bool irq_valid = false;
  30         unsigned int intr;
  31         unsigned int stat;
  32
  33         regmap_read(dev->regmap, SPDIF_INT_REG, &intr);
  34         regmap_read(dev->regmap, SPDIF_STAT_REG, &stat);
  35         regmap_update_bits(dev->regmap, SPDIF_CTRL,
  36                 SPDIF_MASK_ENABLE, 0);
  37         regmap_update_bits(dev->regmap, SPDIF_INT_REG,
  38                 SPDIF_INT_REG_BIT, 0);
  39
  40         if ((stat & SPDIF_EMPTY_FLAG) || (stat & SPDIF_AEMPTY_FLAG)) {
  41                 sf_spdif_pcm_push_tx(dev);
  42                 irq_valid = true;
  43         }
  44
  45         if ((stat & SPDIF_FULL_FLAG) || (stat & SPDIF_AFULL_FLAG)) {
  46                 sf_spdif_pcm_pop_rx(dev);
  47                 irq_valid = true;
  48         }
  49
  50         if (stat & SPDIF_PARITY_FLAG)
  51                 irq_valid = true;
  52
  53         if (stat & SPDIF_UNDERR_FLAG)
  54                 irq_valid = true;
  55
  56         if (stat & SPDIF_OVRERR_FLAG)
  57                 irq_valid = true;
  58
  59         if (stat & SPDIF_SYNCERR_FLAG)
  60                 irq_valid = true;
  61
  62         if (stat & SPDIF_LOCK_FLAG)
  63                 irq_valid = true;
  64
  65         if (stat & SPDIF_BEGIN_FLAG)
  66                 irq_valid = true;
  67
  68         if (stat & SPDIF_RIGHT_LEFT)
  69                 irq_valid = true;
  70
  71         regmap_update_bits(dev->regmap, SPDIF_CTRL,
  72                 SPDIF_MASK_ENABLE, SPDIF_MASK_ENABLE);
  73
  74         if (irq_valid)
  75                 return IRQ_HANDLED;
  76         else
  77                 return IRQ_NONE;
  78 }
  79
  80 static int sf_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
  81         struct snd_soc_dai *dai)
  82 {
  83         struct sf_spdif_dev *spdif = snd_soc_dai_get_drvdata(dai);
  84         bool tx;
  85
  86         tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
  87         if (tx) {
  88                 /* tx mode */
  89                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
  90                         SPDIF_TR_MODE, SPDIF_TR_MODE);
  91
  92                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
  93                         SPDIF_MASK_FIFO, SPDIF_EMPTY_MASK | SPDIF_AEMPTY_MASK);
  94         } else {
  95                 /* rx mode */
  96                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
  97                         SPDIF_TR_MODE, 0);
  98
  99                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 100                         SPDIF_MASK_FIFO, SPDIF_FULL_MASK | SPDIF_AFULL_MASK);
 101         }
 102
 103         switch (cmd) {
 104         case SNDRV_PCM_TRIGGER_START:
 105         case SNDRV_PCM_TRIGGER_RESUME:
 106         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 107                 /* clock recovery form the SPDIF data stream  0:clk_enable */
 108                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 109                         SPDIF_CLK_ENABLE, 0);
 110
 111                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 112                         SPDIF_ENABLE, SPDIF_ENABLE);
 113                 break;
 114         case SNDRV_PCM_TRIGGER_STOP:
 115         case SNDRV_PCM_TRIGGER_SUSPEND:
 116         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 117                 /* clock recovery form the SPDIF data stream  1:power save mode */
 118                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 119                         SPDIF_CLK_ENABLE, SPDIF_CLK_ENABLE);
 120
 121                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 122                         SPDIF_ENABLE, 0);
 123                 break;
 124         default:
 125                 dev_err(dai->dev, "%s L.%d cmd:%d\n", __func__, __LINE__, cmd);
 126                 return -EINVAL;
 127         }
 128
 129         return 0;
 130 }
 131
 132 static int sf_spdif_hw_params(struct snd_pcm_substream *substream,
 133         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 134 {
 135         struct sf_spdif_dev *spdif = snd_soc_dai_get_drvdata(dai);
 136         unsigned int channels;
 137         unsigned int rate;
 138         unsigned int format;
 139         unsigned int tsamplerate;
 140         unsigned int mclk;
 141         unsigned int audio_root;
 142         int ret;
 143
 144         channels = params_channels(params);
 145         rate = params_rate(params);
 146         format = params_format(params);
 147
 148         switch (channels) {
 149         case 1:
 150                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 151                         SPDIF_CHANNEL_MODE, SPDIF_CHANNEL_MODE);
 152                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 153                         SPDIF_DUPLICATE, SPDIF_DUPLICATE);
 154                 spdif->channels = false;
 155                 break;
 156         case 2:
 157                 regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 158                         SPDIF_CHANNEL_MODE, 0);
 159                 spdif->channels = true;
 160                 break;
 161         default:
 162                 dev_err(dai->dev, "invalid channels number\n");
 163                 return -EINVAL;
 164         }
 165
 166         switch (format) {
 167         case SNDRV_PCM_FORMAT_S16_LE:
 168         case SNDRV_PCM_FORMAT_S24_LE:
 169         case SNDRV_PCM_FORMAT_S24_3LE:
 170         case SNDRV_PCM_FORMAT_S32_LE:
 171                 break;
 172         default:
 173                 dev_err(dai->dev, "invalid format\n");
 174                 return -EINVAL;
 175         }
 176
 177         audio_root = 204800000;
 178         switch (rate) {
 179         case 8000:
 180                 mclk = 4096000;
 181                 break;
 182         case 11025:
 183                 mclk = 5644800;
 184                 break;
 185         case 16000:
 186                 mclk = 8192000;
 187                 break;
 188         case 22050:
 189                 audio_root = 153600000;
 190                 mclk = 11289600;
 191                 break;
 192         default:
 193                 dev_err(dai->dev, "channel:%d sample rate:%d\n", channels, rate);
 194                 return -EINVAL;
 195         }
 196
 197         ret = clk_set_rate(spdif->audio_root, audio_root);
 198         if (ret) {
 199                 dev_err(dai->dev, "failed to set audio_root rate :%d\n", ret);
 200                 return ret;
 201         }
 202         dev_dbg(dai->dev, "audio_root get rate:%ld\n",
 203                         clk_get_rate(spdif->audio_root));
 204
 205         ret = clk_set_rate(spdif->mclk_inner, mclk);
 206         if (ret) {
 207                 dev_err(dai->dev, "failed to set mclk_inner rate :%d\n", ret);
 208                 return ret;
 209         }
 210
 211         mclk = clk_get_rate(spdif->mclk_inner);
 212         dev_dbg(dai->dev, "mclk_inner get rate:%d\n", mclk);
 213         /* (FCLK)4096000/128=32000 */
 214         tsamplerate = (mclk / 128 + rate / 2) / rate - 1;
 215         if (tsamplerate < 3)
 216                 tsamplerate = 3;
 217
 218         /* transmission sample rate */
 219         regmap_update_bits(spdif->regmap, SPDIF_CTRL, 0xFF, tsamplerate);
 220
 221         return 0;
 222 }
 223
 224 static int sf_spdif_clks_get(struct platform_device *pdev,
 225                                 struct sf_spdif_dev *spdif)
 226 {
 227         static struct clk_bulk_data clks[] = {
 228                 { .id = "spdif-apb" },          /* clock-names in dts file */
 229                 { .id = "spdif-core" },
 230                 { .id = "audroot" },
 231                 { .id = "mclk_inner"},
 232         };
 233         int ret = devm_clk_bulk_get(&pdev->dev, ARRAY_SIZE(clks), clks);
 234
 235         spdif->spdif_apb = clks[0].clk;
 236         spdif->spdif_core = clks[1].clk;
 237         spdif->audio_root = clks[2].clk;
 238         spdif->mclk_inner = clks[3].clk;
 239         return ret;
 240 }
 241
 242 static int sf_spdif_resets_get(struct platform_device *pdev,
 243                                 struct sf_spdif_dev *spdif)
 244 {
 245         struct reset_control_bulk_data resets[] = {
 246                         { .id = "rst_apb" },
 247         };
 248         int ret = devm_reset_control_bulk_get_exclusive(&pdev->dev, ARRAY_SIZE(resets), resets);
 249
 250         if (ret)
 251                 return ret;
 252
 253         spdif->rst_apb = resets[0].rstc;
 254
 255         return 0;
 256 }
 257
 258 static int sf_spdif_clk_init(struct platform_device *pdev,
 259                                 struct sf_spdif_dev *spdif)
 260 {
 261         int ret = 0;
 262
 263         ret = clk_prepare_enable(spdif->spdif_apb);
 264         if (ret) {
 265                 dev_err(&pdev->dev, "failed to prepare enable spdif_apb\n");
 266                 goto disable_apb_clk;
 267         }
 268
 269         ret = clk_prepare_enable(spdif->spdif_core);
 270         if (ret) {
 271                 dev_err(&pdev->dev, "failed to prepare enable spdif_core\n");
 272                 goto disable_core_clk;
 273         }
 274
 275         ret = clk_set_rate(spdif->audio_root, 204800000);
 276         if (ret) {
 277                 dev_err(&pdev->dev, "failed to set rate for spdif audroot ret=%d\n", ret);
 278                 goto disable_core_clk;
 279         }
 280
 281         ret = clk_set_rate(spdif->mclk_inner, 8192000);
 282         if (ret) {
 283                 dev_err(&pdev->dev, "failed to set rate for spdif mclk_inner ret=%d\n", ret);
 284                 goto disable_core_clk;
 285         }
 286
 287         dev_dbg(&pdev->dev, "spdif->spdif_apb = %lu\n", clk_get_rate(spdif->spdif_apb));
 288         dev_dbg(&pdev->dev, "spdif->spdif_core = %lu\n", clk_get_rate(spdif->spdif_core));
 289
 290         ret = reset_control_deassert(spdif->rst_apb);
 291         if (ret) {
 292                 dev_err(&pdev->dev, "failed to deassert apb\n");
 293                 goto disable_core_clk;
 294         }
 295
 296         return 0;
 297
 298 disable_core_clk:
 299         clk_disable_unprepare(spdif->spdif_core);
 300 disable_apb_clk:
 301         clk_disable_unprepare(spdif->spdif_apb);
 302
 303         return ret;
 304 }
 305
 306 static int sf_spdif_dai_probe(struct snd_soc_dai *dai)
 307 {
 308         struct sf_spdif_dev *spdif = snd_soc_dai_get_drvdata(dai);
 309
 310         /* reset */
 311         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 312                 SPDIF_ENABLE | SPDIF_SFR_ENABLE | SPDIF_FIFO_ENABLE, 0);
 313
 314         /* clear irq */
 315         regmap_update_bits(spdif->regmap, SPDIF_INT_REG,
 316                 SPDIF_INT_REG_BIT, 0);
 317
 318         /* power save mode */
 319         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 320                 SPDIF_CLK_ENABLE, SPDIF_CLK_ENABLE);
 321
 322         /* power save mode */
 323         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 324                 SPDIF_CLK_ENABLE, SPDIF_CLK_ENABLE);
 325
 326         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 327                 SPDIF_PARITCHECK|SPDIF_VALIDITYCHECK|SPDIF_DUPLICATE,
 328                 SPDIF_PARITCHECK|SPDIF_VALIDITYCHECK|SPDIF_DUPLICATE);
 329
 330         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 331                 SPDIF_SETPREAMBB, SPDIF_SETPREAMBB);
 332
 333         regmap_update_bits(spdif->regmap, SPDIF_INT_REG,
 334                 BIT8TO20MASK<<SPDIF_PREAMBLEDEL, 0x3<<SPDIF_PREAMBLEDEL);
 335
 336         regmap_update_bits(spdif->regmap, SPDIF_FIFO_CTRL,
 337                 ALLBITMASK, 0x20|(0x20<<SPDIF_AFULL_THRESHOLD));
 338
 339         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 340                 SPDIF_PARITYGEN, SPDIF_PARITYGEN);
 341
 342         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 343                 SPDIF_MASK_ENABLE, SPDIF_MASK_ENABLE);
 344
 345         /* APB access to FIFO enable, disable if use DMA/FIFO */
 346         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 347                 SPDIF_USE_FIFO_IF, 0);
 348
 349         /* two channel */
 350         regmap_update_bits(spdif->regmap, SPDIF_CTRL,
 351                 SPDIF_CHANNEL_MODE, 0);
 352
 353         return 0;
 354 }
 355
 356 static const struct snd_soc_dai_ops sf_spdif_dai_ops = {
 357         .trigger = sf_spdif_trigger,
 358         .hw_params = sf_spdif_hw_params,
 359 };
 360
 361 #define SF_PCM_RATE_44100_192000  (SNDRV_PCM_RATE_44100 | \
 362                                    SNDRV_PCM_RATE_48000 | \
 363                                    SNDRV_PCM_RATE_96000 | \
 364                                    SNDRV_PCM_RATE_192000)
 365
 366 #define SF_PCM_RATE_8000_22050  (SNDRV_PCM_RATE_8000 | \
 367                                  SNDRV_PCM_RATE_11025 | \
 368                                  SNDRV_PCM_RATE_16000 | \
 369                                  SNDRV_PCM_RATE_22050)
 370
 371 static struct snd_soc_dai_driver sf_spdif_dai = {
 372         .name = "spdif",
 373         .id = 0,
 374         .probe = sf_spdif_dai_probe,
 375         .playback = {
 376                 .stream_name = "Playback",
 377                 .channels_min = 1,
 378                 .channels_max = 2,
 379                 .rates = SF_PCM_RATE_8000_22050,
 380                 .formats = SNDRV_PCM_FMTBIT_S16_LE |
 381                            SNDRV_PCM_FMTBIT_S24_LE |
 382                            SNDRV_PCM_FMTBIT_S24_3LE |
 383                            SNDRV_PCM_FMTBIT_S32_LE,
 384         },
 385         .ops = &sf_spdif_dai_ops,
 386         .symmetric_rate = 1,
 387 };
 388
 389 static const struct snd_soc_component_driver sf_spdif_component = {
 390         .name = "starfive-spdif",
 391 };
 392
 393 static const struct regmap_config sf_spdif_regmap_config = {
 394         .reg_bits = 32,
 395         .reg_stride = 4,
 396         .val_bits = 32,
 397         .max_register = 0x200,
 398 };
 399
 400 static int sf_spdif_probe(struct platform_device *pdev)
 401 {
 402         struct sf_spdif_dev *spdif;
 403         struct resource *res;
 404         void __iomem *base;
 405         int ret;
 406         int irq;
 407
 408         spdif = devm_kzalloc(&pdev->dev, sizeof(*spdif), GFP_KERNEL);
 409         if (!spdif)
 410                 return -ENOMEM;
 411
 412         platform_set_drvdata(pdev, spdif);
 413
 414         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 415         base = devm_ioremap_resource(&pdev->dev, res);
 416         if (IS_ERR(base))
 417                 return PTR_ERR(base);
 418
 419         spdif->spdif_base = base;
 420         spdif->regmap = devm_regmap_init_mmio(&pdev->dev, spdif->spdif_base,
 421                                             &sf_spdif_regmap_config);
 422         if (IS_ERR(spdif->regmap))
 423                 return PTR_ERR(spdif->regmap);
 424
 425         ret = sf_spdif_clks_get(pdev, spdif);
 426         if (ret) {
 427                 dev_err(&pdev->dev, "failed to get audio clock\n");
 428                 return ret;
 429         }
 430
 431         ret = sf_spdif_resets_get(pdev, spdif);
 432         if (ret) {
 433                 dev_err(&pdev->dev, "failed to get audio reset controls\n");
 434                 return ret;
 435         }
 436
 437         ret = sf_spdif_clk_init(pdev, spdif);
 438         if (ret) {
 439                 dev_err(&pdev->dev, "failed to enable audio clock\n");
 440                 return ret;
 441         }
 442
 443         spdif->dev = &pdev->dev;
 444         spdif->fifo_th = 16;
 445
 446         irq = platform_get_irq(pdev, 0);
 447         if (irq >= 0) {
 448                 ret = devm_request_irq(&pdev->dev, irq, spdif_irq_handler, 0,
 449                                 pdev->name, spdif);
 450                 if (ret < 0) {
 451                         dev_err(&pdev->dev, "failed to request irq\n");
 452                         return ret;
 453                 }
 454         }
 455
 456         ret = devm_snd_soc_register_component(&pdev->dev, &sf_spdif_component,
 457                                          &sf_spdif_dai, 1);
 458         if (ret)
 459                 goto err_clk_disable;
 460
 461         if (irq >= 0) {
 462                 ret = sf_spdif_pcm_register(pdev);
 463                 spdif->use_pio = true;
 464         } else {
 465                 ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL,
 466                                         0);
 467                 spdif->use_pio = false;
 468         }
 469
 470         if (ret)
 471                 goto err_clk_disable;
 472
 473         return 0;
 474
 475 err_clk_disable:
 476         return ret;
 477 }
 478
 479 static const struct of_device_id sf_spdif_of_match[] = {
 480         { .compatible = "starfive,jh7110-spdif", },
 481         {},
 482 };
 483 MODULE_DEVICE_TABLE(of, sf_spdif_of_match);
 484
 485 static struct platform_driver sf_spdif_driver = {
 486         .driver = {
 487                 .name = "starfive-spdif",
 488                 .of_match_table = sf_spdif_of_match,
 489         },
 490         .probe = sf_spdif_probe,
 491 };
 492 module_platform_driver(sf_spdif_driver);
 493
 494 MODULE_AUTHOR("curry.zhang <curry.zhang@starfive.com>");
 495 MODULE_DESCRIPTION("starfive SPDIF driver");
 496 MODULE_LICENSE("GPL v2");