sound/soc/samsung/pcm.c

   1 /* sound/soc/samsung/pcm.c
   2  *
   3  * ALSA SoC Audio Layer - S3C PCM-Controller driver
   4  *
   5  * Copyright (c) 2009 Samsung Electronics Co. Ltd
   6  * Author: Jaswinder Singh <jassi.brar@samsung.com>
   7  * based upon I2S drivers by Ben Dooks.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/device.h>
  17 #include <linux/delay.h>
  18 #include <linux/clk.h>
  19 #include <linux/kernel.h>
  20 #include <linux/gpio.h>
  21 #include <linux/io.h>
  22
  23 #include <sound/core.h>
  24 #include <sound/pcm.h>
  25 #include <sound/pcm_params.h>
  26 #include <sound/initval.h>
  27 #include <sound/soc.h>
  28
  29 #include <plat/audio.h>
  30 #include <plat/dma.h>
  31
  32 #include "dma.h"
  33 #include "pcm.h"
  34
  35 static struct s3c2410_dma_client s3c_pcm_dma_client_out = {
  36         .name           = "PCM Stereo out"
  37 };
  38
  39 static struct s3c2410_dma_client s3c_pcm_dma_client_in = {
  40         .name           = "PCM Stereo in"
  41 };
  42
  43 static struct s3c_dma_params s3c_pcm_stereo_out[] = {
  44         [0] = {
  45                 .client         = &s3c_pcm_dma_client_out,
  46                 .dma_size       = 4,
  47         },
  48         [1] = {
  49                 .client         = &s3c_pcm_dma_client_out,
  50                 .dma_size       = 4,
  51         },
  52 };
  53
  54 static struct s3c_dma_params s3c_pcm_stereo_in[] = {
  55         [0] = {
  56                 .client         = &s3c_pcm_dma_client_in,
  57                 .dma_size       = 4,
  58         },
  59         [1] = {
  60                 .client         = &s3c_pcm_dma_client_in,
  61                 .dma_size       = 4,
  62         },
  63 };
  64
  65 static struct s3c_pcm_info s3c_pcm[2];
  66
  67 static void s3c_pcm_snd_txctrl(struct s3c_pcm_info *pcm, int on)
  68 {
  69         void __iomem *regs = pcm->regs;
  70         u32 ctl, clkctl;
  71
  72         clkctl = readl(regs + S3C_PCM_CLKCTL);
  73         ctl = readl(regs + S3C_PCM_CTL);
  74         ctl &= ~(S3C_PCM_CTL_TXDIPSTICK_MASK
  75                          << S3C_PCM_CTL_TXDIPSTICK_SHIFT);
  76
  77         if (on) {
  78                 ctl |= S3C_PCM_CTL_TXDMA_EN;
  79                 ctl |= S3C_PCM_CTL_TXFIFO_EN;
  80                 ctl |= S3C_PCM_CTL_ENABLE;
  81                 ctl |= (0x4<<S3C_PCM_CTL_TXDIPSTICK_SHIFT);
  82                 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
  83         } else {
  84                 ctl &= ~S3C_PCM_CTL_TXDMA_EN;
  85                 ctl &= ~S3C_PCM_CTL_TXFIFO_EN;
  86
  87                 if (!(ctl & S3C_PCM_CTL_RXFIFO_EN)) {
  88                         ctl &= ~S3C_PCM_CTL_ENABLE;
  89                         if (!pcm->idleclk)
  90                                 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
  91                 }
  92         }
  93
  94         writel(clkctl, regs + S3C_PCM_CLKCTL);
  95         writel(ctl, regs + S3C_PCM_CTL);
  96 }
  97
  98 static void s3c_pcm_snd_rxctrl(struct s3c_pcm_info *pcm, int on)
  99 {
 100         void __iomem *regs = pcm->regs;
 101         u32 ctl, clkctl;
 102
 103         ctl = readl(regs + S3C_PCM_CTL);
 104         clkctl = readl(regs + S3C_PCM_CLKCTL);
 105         ctl &= ~(S3C_PCM_CTL_RXDIPSTICK_MASK
 106                          << S3C_PCM_CTL_RXDIPSTICK_SHIFT);
 107
 108         if (on) {
 109                 ctl |= S3C_PCM_CTL_RXDMA_EN;
 110                 ctl |= S3C_PCM_CTL_RXFIFO_EN;
 111                 ctl |= S3C_PCM_CTL_ENABLE;
 112                 ctl |= (0x20<<S3C_PCM_CTL_RXDIPSTICK_SHIFT);
 113                 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
 114         } else {
 115                 ctl &= ~S3C_PCM_CTL_RXDMA_EN;
 116                 ctl &= ~S3C_PCM_CTL_RXFIFO_EN;
 117
 118                 if (!(ctl & S3C_PCM_CTL_TXFIFO_EN)) {
 119                         ctl &= ~S3C_PCM_CTL_ENABLE;
 120                         if (!pcm->idleclk)
 121                                 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
 122                 }
 123         }
 124
 125         writel(clkctl, regs + S3C_PCM_CLKCTL);
 126         writel(ctl, regs + S3C_PCM_CTL);
 127 }
 128
 129 static int s3c_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
 130                                struct snd_soc_dai *dai)
 131 {
 132         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 133         struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(rtd->cpu_dai);
 134         unsigned long flags;
 135
 136         dev_dbg(pcm->dev, "Entered %s\n", __func__);
 137
 138         switch (cmd) {
 139         case SNDRV_PCM_TRIGGER_START:
 140         case SNDRV_PCM_TRIGGER_RESUME:
 141         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 142                 spin_lock_irqsave(&pcm->lock, flags);
 143
 144                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 145                         s3c_pcm_snd_rxctrl(pcm, 1);
 146                 else
 147                         s3c_pcm_snd_txctrl(pcm, 1);
 148
 149                 spin_unlock_irqrestore(&pcm->lock, flags);
 150                 break;
 151
 152         case SNDRV_PCM_TRIGGER_STOP:
 153         case SNDRV_PCM_TRIGGER_SUSPEND:
 154         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 155                 spin_lock_irqsave(&pcm->lock, flags);
 156
 157                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 158                         s3c_pcm_snd_rxctrl(pcm, 0);
 159                 else
 160                         s3c_pcm_snd_txctrl(pcm, 0);
 161
 162                 spin_unlock_irqrestore(&pcm->lock, flags);
 163                 break;
 164
 165         default:
 166                 return -EINVAL;
 167         }
 168
 169         return 0;
 170 }
 171
 172 static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
 173                                  struct snd_pcm_hw_params *params,
 174                                  struct snd_soc_dai *socdai)
 175 {
 176         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 177         struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(rtd->cpu_dai);
 178         struct s3c_dma_params *dma_data;
 179         void __iomem *regs = pcm->regs;
 180         struct clk *clk;
 181         int sclk_div, sync_div;
 182         unsigned long flags;
 183         u32 clkctl;
 184
 185         dev_dbg(pcm->dev, "Entered %s\n", __func__);
 186
 187         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 188                 dma_data = pcm->dma_playback;
 189         else
 190                 dma_data = pcm->dma_capture;
 191
 192         snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_data);
 193
 194         /* Strictly check for sample size */
 195         switch (params_format(params)) {
 196         case SNDRV_PCM_FORMAT_S16_LE:
 197                 break;
 198         default:
 199                 return -EINVAL;
 200         }
 201
 202         spin_lock_irqsave(&pcm->lock, flags);
 203
 204         /* Get hold of the PCMSOURCE_CLK */
 205         clkctl = readl(regs + S3C_PCM_CLKCTL);
 206         if (clkctl & S3C_PCM_CLKCTL_SERCLKSEL_PCLK)
 207                 clk = pcm->pclk;
 208         else
 209                 clk = pcm->cclk;
 210
 211         /* Set the SCLK divider */
 212         sclk_div = clk_get_rate(clk) / pcm->sclk_per_fs /
 213                                         params_rate(params) / 2 - 1;
 214
 215         clkctl &= ~(S3C_PCM_CLKCTL_SCLKDIV_MASK
 216                         << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
 217         clkctl |= ((sclk_div & S3C_PCM_CLKCTL_SCLKDIV_MASK)
 218                         << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
 219
 220         /* Set the SYNC divider */
 221         sync_div = pcm->sclk_per_fs - 1;
 222
 223         clkctl &= ~(S3C_PCM_CLKCTL_SYNCDIV_MASK
 224                                 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
 225         clkctl |= ((sync_div & S3C_PCM_CLKCTL_SYNCDIV_MASK)
 226                                 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
 227
 228         writel(clkctl, regs + S3C_PCM_CLKCTL);
 229
 230         spin_unlock_irqrestore(&pcm->lock, flags);
 231
 232         dev_dbg(pcm->dev, "PCMSOURCE_CLK-%lu SCLK=%ufs SCLK_DIV=%d SYNC_DIV=%d\n",
 233                                 clk_get_rate(clk), pcm->sclk_per_fs,
 234                                 sclk_div, sync_div);
 235
 236         return 0;
 237 }
 238
 239 static int s3c_pcm_set_fmt(struct snd_soc_dai *cpu_dai,
 240                                unsigned int fmt)
 241 {
 242         struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(cpu_dai);
 243         void __iomem *regs = pcm->regs;
 244         unsigned long flags;
 245         int ret = 0;
 246         u32 ctl;
 247
 248         dev_dbg(pcm->dev, "Entered %s\n", __func__);
 249
 250         spin_lock_irqsave(&pcm->lock, flags);
 251
 252         ctl = readl(regs + S3C_PCM_CTL);
 253
 254         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 255         case SND_SOC_DAIFMT_NB_NF:
 256                 /* Nothing to do, NB_NF by default */
 257                 break;
 258         default:
 259                 dev_err(pcm->dev, "Unsupported clock inversion!\n");
 260                 ret = -EINVAL;
 261                 goto exit;
 262         }
 263
 264         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 265         case SND_SOC_DAIFMT_CBS_CFS:
 266                 /* Nothing to do, Master by default */
 267                 break;
 268         default:
 269                 dev_err(pcm->dev, "Unsupported master/slave format!\n");
 270                 ret = -EINVAL;
 271                 goto exit;
 272         }
 273
 274         switch (fmt & SND_SOC_DAIFMT_CLOCK_MASK) {
 275         case SND_SOC_DAIFMT_CONT:
 276                 pcm->idleclk = 1;
 277                 break;
 278         case SND_SOC_DAIFMT_GATED:
 279                 pcm->idleclk = 0;
 280                 break;
 281         default:
 282                 dev_err(pcm->dev, "Invalid Clock gating request!\n");
 283                 ret = -EINVAL;
 284                 goto exit;
 285         }
 286
 287         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 288         case SND_SOC_DAIFMT_DSP_A:
 289                 ctl |= S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
 290                 ctl |= S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
 291                 break;
 292         case SND_SOC_DAIFMT_DSP_B:
 293                 ctl &= ~S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
 294                 ctl &= ~S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
 295                 break;
 296         default:
 297                 dev_err(pcm->dev, "Unsupported data format!\n");
 298                 ret = -EINVAL;
 299                 goto exit;
 300         }
 301
 302         writel(ctl, regs + S3C_PCM_CTL);
 303
 304 exit:
 305         spin_unlock_irqrestore(&pcm->lock, flags);
 306
 307         return ret;
 308 }
 309
 310 static int s3c_pcm_set_clkdiv(struct snd_soc_dai *cpu_dai,
 311                                                 int div_id, int div)
 312 {
 313         struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(cpu_dai);
 314
 315         switch (div_id) {
 316         case S3C_PCM_SCLK_PER_FS:
 317                 pcm->sclk_per_fs = div;
 318                 break;
 319
 320         default:
 321                 return -EINVAL;
 322         }
 323
 324         return 0;
 325 }
 326
 327 static int s3c_pcm_set_sysclk(struct snd_soc_dai *cpu_dai,
 328                                   int clk_id, unsigned int freq, int dir)
 329 {
 330         struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(cpu_dai);
 331         void __iomem *regs = pcm->regs;
 332         u32 clkctl = readl(regs + S3C_PCM_CLKCTL);
 333
 334         switch (clk_id) {
 335         case S3C_PCM_CLKSRC_PCLK:
 336                 clkctl |= S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
 337                 break;
 338
 339         case S3C_PCM_CLKSRC_MUX:
 340                 clkctl &= ~S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
 341
 342                 if (clk_get_rate(pcm->cclk) != freq)
 343                         clk_set_rate(pcm->cclk, freq);
 344
 345                 break;
 346
 347         default:
 348                 return -EINVAL;
 349         }
 350
 351         writel(clkctl, regs + S3C_PCM_CLKCTL);
 352
 353         return 0;
 354 }
 355
 356 static struct snd_soc_dai_ops s3c_pcm_dai_ops = {
 357         .set_sysclk     = s3c_pcm_set_sysclk,
 358         .set_clkdiv     = s3c_pcm_set_clkdiv,
 359         .trigger        = s3c_pcm_trigger,
 360         .hw_params      = s3c_pcm_hw_params,
 361         .set_fmt        = s3c_pcm_set_fmt,
 362 };
 363
 364 #define S3C_PCM_RATES  SNDRV_PCM_RATE_8000_96000
 365
 366 #define S3C_PCM_DAI_DECLARE                     \
 367         .symmetric_rates = 1,                                   \
 368         .ops = &s3c_pcm_dai_ops,                                \
 369         .playback = {                                           \
 370                 .channels_min   = 2,                            \
 371                 .channels_max   = 2,                            \
 372                 .rates          = S3C_PCM_RATES,                \
 373                 .formats        = SNDRV_PCM_FMTBIT_S16_LE,      \
 374         },                                                      \
 375         .capture = {                                            \
 376                 .channels_min   = 2,                            \
 377                 .channels_max   = 2,                            \
 378                 .rates          = S3C_PCM_RATES,                \
 379                 .formats        = SNDRV_PCM_FMTBIT_S16_LE,      \
 380         }
 381
 382 struct snd_soc_dai_driver s3c_pcm_dai[] = {
 383         [0] = {
 384                 .name   = "samsung-pcm.0",
 385                 S3C_PCM_DAI_DECLARE,
 386         },
 387         [1] = {
 388                 .name   = "samsung-pcm.1",
 389                 S3C_PCM_DAI_DECLARE,
 390         },
 391 };
 392 EXPORT_SYMBOL_GPL(s3c_pcm_dai);
 393
 394 static __devinit int s3c_pcm_dev_probe(struct platform_device *pdev)
 395 {
 396         struct s3c_pcm_info *pcm;
 397         struct resource *mem_res, *dmatx_res, *dmarx_res;
 398         struct s3c_audio_pdata *pcm_pdata;
 399         int ret;
 400
 401         /* Check for valid device index */
 402         if ((pdev->id < 0) || pdev->id >= ARRAY_SIZE(s3c_pcm)) {
 403                 dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
 404                 return -EINVAL;
 405         }
 406
 407         pcm_pdata = pdev->dev.platform_data;
 408
 409         /* Check for availability of necessary resource */
 410         dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
 411         if (!dmatx_res) {
 412                 dev_err(&pdev->dev, "Unable to get PCM-TX dma resource\n");
 413                 return -ENXIO;
 414         }
 415
 416         dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
 417         if (!dmarx_res) {
 418                 dev_err(&pdev->dev, "Unable to get PCM-RX dma resource\n");
 419                 return -ENXIO;
 420         }
 421
 422         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 423         if (!mem_res) {
 424                 dev_err(&pdev->dev, "Unable to get register resource\n");
 425                 return -ENXIO;
 426         }
 427
 428         if (pcm_pdata && pcm_pdata->cfg_gpio && pcm_pdata->cfg_gpio(pdev)) {
 429                 dev_err(&pdev->dev, "Unable to configure gpio\n");
 430                 return -EINVAL;
 431         }
 432
 433         pcm = &s3c_pcm[pdev->id];
 434         pcm->dev = &pdev->dev;
 435
 436         spin_lock_init(&pcm->lock);
 437
 438         /* Default is 128fs */
 439         pcm->sclk_per_fs = 128;
 440
 441         pcm->cclk = clk_get(&pdev->dev, "audio-bus");
 442         if (IS_ERR(pcm->cclk)) {
 443                 dev_err(&pdev->dev, "failed to get audio-bus\n");
 444                 ret = PTR_ERR(pcm->cclk);
 445                 goto err1;
 446         }
 447         clk_enable(pcm->cclk);
 448
 449         /* record our pcm structure for later use in the callbacks */
 450         dev_set_drvdata(&pdev->dev, pcm);
 451
 452         if (!request_mem_region(mem_res->start,
 453                                 resource_size(mem_res), "samsung-pcm")) {
 454                 dev_err(&pdev->dev, "Unable to request register region\n");
 455                 ret = -EBUSY;
 456                 goto err2;
 457         }
 458
 459         pcm->regs = ioremap(mem_res->start, 0x100);
 460         if (pcm->regs == NULL) {
 461                 dev_err(&pdev->dev, "cannot ioremap registers\n");
 462                 ret = -ENXIO;
 463                 goto err3;
 464         }
 465
 466         pcm->pclk = clk_get(&pdev->dev, "pcm");
 467         if (IS_ERR(pcm->pclk)) {
 468                 dev_err(&pdev->dev, "failed to get pcm_clock\n");
 469                 ret = -ENOENT;
 470                 goto err4;
 471         }
 472         clk_enable(pcm->pclk);
 473
 474         ret = snd_soc_register_dai(&pdev->dev, &s3c_pcm_dai[pdev->id]);
 475         if (ret != 0) {
 476                 dev_err(&pdev->dev, "failed to get pcm_clock\n");
 477                 goto err5;
 478         }
 479
 480         s3c_pcm_stereo_in[pdev->id].dma_addr = mem_res->start
 481                                                         + S3C_PCM_RXFIFO;
 482         s3c_pcm_stereo_out[pdev->id].dma_addr = mem_res->start
 483                                                         + S3C_PCM_TXFIFO;
 484
 485         s3c_pcm_stereo_in[pdev->id].channel = dmarx_res->start;
 486         s3c_pcm_stereo_out[pdev->id].channel = dmatx_res->start;
 487
 488         pcm->dma_capture = &s3c_pcm_stereo_in[pdev->id];
 489         pcm->dma_playback = &s3c_pcm_stereo_out[pdev->id];
 490
 491         return 0;
 492
 493 err5:
 494         clk_disable(pcm->pclk);
 495         clk_put(pcm->pclk);
 496 err4:
 497         iounmap(pcm->regs);
 498 err3:
 499         release_mem_region(mem_res->start, resource_size(mem_res));
 500 err2:
 501         clk_disable(pcm->cclk);
 502         clk_put(pcm->cclk);
 503 err1:
 504         return ret;
 505 }
 506
 507 static __devexit int s3c_pcm_dev_remove(struct platform_device *pdev)
 508 {
 509         struct s3c_pcm_info *pcm = &s3c_pcm[pdev->id];
 510         struct resource *mem_res;
 511
 512         snd_soc_unregister_dai(&pdev->dev);
 513
 514         iounmap(pcm->regs);
 515
 516         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 517         release_mem_region(mem_res->start, resource_size(mem_res));
 518
 519         clk_disable(pcm->cclk);
 520         clk_disable(pcm->pclk);
 521         clk_put(pcm->pclk);
 522         clk_put(pcm->cclk);
 523
 524         return 0;
 525 }
 526
 527 static struct platform_driver s3c_pcm_driver = {
 528         .probe  = s3c_pcm_dev_probe,
 529         .remove = s3c_pcm_dev_remove,
 530         .driver = {
 531                 .name = "samsung-pcm",
 532                 .owner = THIS_MODULE,
 533         },
 534 };
 535
 536 static int __init s3c_pcm_init(void)
 537 {
 538         return platform_driver_register(&s3c_pcm_driver);
 539 }
 540 module_init(s3c_pcm_init);
 541
 542 static void __exit s3c_pcm_exit(void)
 543 {
 544         platform_driver_unregister(&s3c_pcm_driver);
 545 }
 546 module_exit(s3c_pcm_exit);
 547
 548 /* Module information */
 549 MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
 550 MODULE_DESCRIPTION("S3C PCM Controller Driver");
 551 MODULE_LICENSE("GPL");
 552 MODULE_ALIAS("platform:samsung-pcm");