sound/soc/intel/sst-baytrail-pcm.c

   1 /*
   2  * Intel Baytrail SST PCM Support
   3  * Copyright (c) 2014, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/slab.h>
  18 #include <sound/core.h>
  19 #include <sound/pcm.h>
  20 #include <sound/pcm_params.h>
  21 #include <sound/soc.h>
  22 #include "sst-baytrail-ipc.h"
  23 #include "sst-dsp-priv.h"
  24 #include "sst-dsp.h"
  25
  26 #define BYT_PCM_COUNT           2
  27
  28 static const struct snd_pcm_hardware sst_byt_pcm_hardware = {
  29         .info                   = SNDRV_PCM_INFO_MMAP |
  30                                   SNDRV_PCM_INFO_MMAP_VALID |
  31                                   SNDRV_PCM_INFO_INTERLEAVED |
  32                                   SNDRV_PCM_INFO_PAUSE |
  33                                   SNDRV_PCM_INFO_RESUME,
  34         .formats                = SNDRV_PCM_FMTBIT_S16_LE |
  35                                   SNDRV_PCM_FORMAT_S24_LE,
  36         .period_bytes_min       = 384,
  37         .period_bytes_max       = 48000,
  38         .periods_min            = 2,
  39         .periods_max            = 250,
  40         .buffer_bytes_max       = 96000,
  41 };
  42
  43 /* private data for each PCM DSP stream */
  44 struct sst_byt_pcm_data {
  45         struct sst_byt_stream *stream;
  46         struct snd_pcm_substream *substream;
  47         struct mutex mutex;
  48
  49         /* latest DSP DMA hw pointer */
  50         u32 hw_ptr;
  51
  52         struct work_struct work;
  53 };
  54
  55 /* private data for the driver */
  56 struct sst_byt_priv_data {
  57         /* runtime DSP */
  58         struct sst_byt *byt;
  59
  60         /* DAI data */
  61         struct sst_byt_pcm_data pcm[BYT_PCM_COUNT];
  62 };
  63
  64 /* this may get called several times by oss emulation */
  65 static int sst_byt_pcm_hw_params(struct snd_pcm_substream *substream,
  66                                  struct snd_pcm_hw_params *params)
  67 {
  68         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  69         struct sst_byt_priv_data *pdata =
  70                 snd_soc_platform_get_drvdata(rtd->platform);
  71         struct sst_byt_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
  72         struct sst_byt *byt = pdata->byt;
  73         u32 rate, bits;
  74         u8 channels;
  75         int ret, playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
  76
  77         dev_dbg(rtd->dev, "PCM: hw_params, pcm_data %p\n", pcm_data);
  78
  79         ret = sst_byt_stream_type(byt, pcm_data->stream,
  80                                   1, 1, !playback);
  81         if (ret < 0) {
  82                 dev_err(rtd->dev, "failed to set stream format %d\n", ret);
  83                 return ret;
  84         }
  85
  86         rate = params_rate(params);
  87         ret = sst_byt_stream_set_rate(byt, pcm_data->stream, rate);
  88         if (ret < 0) {
  89                 dev_err(rtd->dev, "could not set rate %d\n", rate);
  90                 return ret;
  91         }
  92
  93         bits = snd_pcm_format_width(params_format(params));
  94         ret = sst_byt_stream_set_bits(byt, pcm_data->stream, bits);
  95         if (ret < 0) {
  96                 dev_err(rtd->dev, "could not set formats %d\n",
  97                         params_rate(params));
  98                 return ret;
  99         }
 100
 101         channels = (u8)(params_channels(params) & 0xF);
 102         ret = sst_byt_stream_set_channels(byt, pcm_data->stream, channels);
 103         if (ret < 0) {
 104                 dev_err(rtd->dev, "could not set channels %d\n",
 105                         params_rate(params));
 106                 return ret;
 107         }
 108
 109         snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
 110
 111         ret = sst_byt_stream_buffer(byt, pcm_data->stream,
 112                                     substream->dma_buffer.addr,
 113                                     params_buffer_bytes(params));
 114         if (ret < 0) {
 115                 dev_err(rtd->dev, "PCM: failed to set DMA buffer %d\n", ret);
 116                 return ret;
 117         }
 118
 119         ret = sst_byt_stream_commit(byt, pcm_data->stream);
 120         if (ret < 0) {
 121                 dev_err(rtd->dev, "PCM: failed stream commit %d\n", ret);
 122                 return ret;
 123         }
 124
 125         return 0;
 126 }
 127
 128 static int sst_byt_pcm_hw_free(struct snd_pcm_substream *substream)
 129 {
 130         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 131
 132         dev_dbg(rtd->dev, "PCM: hw_free\n");
 133         snd_pcm_lib_free_pages(substream);
 134
 135         return 0;
 136 }
 137
 138 static int sst_byt_pcm_restore_stream_context(struct snd_pcm_substream *substream)
 139 {
 140         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 141         struct sst_byt_priv_data *pdata =
 142                 snd_soc_platform_get_drvdata(rtd->platform);
 143         struct sst_byt_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
 144         struct sst_byt *byt = pdata->byt;
 145         int ret;
 146
 147         /* commit stream using existing stream params */
 148         ret = sst_byt_stream_commit(byt, pcm_data->stream);
 149         if (ret < 0) {
 150                 dev_err(rtd->dev, "PCM: failed stream commit %d\n", ret);
 151                 return ret;
 152         }
 153
 154         sst_byt_stream_start(byt, pcm_data->stream, pcm_data->hw_ptr);
 155
 156         dev_dbg(rtd->dev, "stream context restored at offset %d\n",
 157                 pcm_data->hw_ptr);
 158
 159         return 0;
 160 }
 161
 162 static void sst_byt_pcm_work(struct work_struct *work)
 163 {
 164         struct sst_byt_pcm_data *pcm_data =
 165                 container_of(work, struct sst_byt_pcm_data, work);
 166
 167         sst_byt_pcm_restore_stream_context(pcm_data->substream);
 168 }
 169
 170 static int sst_byt_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 171 {
 172         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 173         struct sst_byt_priv_data *pdata =
 174                 snd_soc_platform_get_drvdata(rtd->platform);
 175         struct sst_byt_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
 176         struct sst_byt *byt = pdata->byt;
 177
 178         dev_dbg(rtd->dev, "PCM: trigger %d\n", cmd);
 179
 180         switch (cmd) {
 181         case SNDRV_PCM_TRIGGER_START:
 182                 sst_byt_stream_start(byt, pcm_data->stream, 0);
 183                 break;
 184         case SNDRV_PCM_TRIGGER_RESUME:
 185                 schedule_work(&pcm_data->work);
 186                 break;
 187         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 188                 sst_byt_stream_resume(byt, pcm_data->stream);
 189                 break;
 190         case SNDRV_PCM_TRIGGER_STOP:
 191                 sst_byt_stream_stop(byt, pcm_data->stream);
 192                 break;
 193         case SNDRV_PCM_TRIGGER_SUSPEND:
 194         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 195                 sst_byt_stream_pause(byt, pcm_data->stream);
 196                 break;
 197         default:
 198                 break;
 199         }
 200
 201         return 0;
 202 }
 203
 204 static u32 byt_notify_pointer(struct sst_byt_stream *stream, void *data)
 205 {
 206         struct sst_byt_pcm_data *pcm_data = data;
 207         struct snd_pcm_substream *substream = pcm_data->substream;
 208         struct snd_pcm_runtime *runtime = substream->runtime;
 209         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 210         struct sst_byt_priv_data *pdata =
 211                 snd_soc_platform_get_drvdata(rtd->platform);
 212         struct sst_byt *byt = pdata->byt;
 213         u32 pos, hw_pos;
 214
 215         hw_pos = sst_byt_get_dsp_position(byt, pcm_data->stream,
 216                                           snd_pcm_lib_buffer_bytes(substream));
 217         pcm_data->hw_ptr = hw_pos;
 218         pos = frames_to_bytes(runtime,
 219                               (runtime->control->appl_ptr %
 220                                runtime->buffer_size));
 221
 222         dev_dbg(rtd->dev, "PCM: App/DMA pointer %u/%u bytes\n", pos, hw_pos);
 223
 224         snd_pcm_period_elapsed(substream);
 225         return pos;
 226 }
 227
 228 static snd_pcm_uframes_t sst_byt_pcm_pointer(struct snd_pcm_substream *substream)
 229 {
 230         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 231         struct snd_pcm_runtime *runtime = substream->runtime;
 232         struct sst_byt_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
 233
 234         dev_dbg(rtd->dev, "PCM: DMA pointer %u bytes\n", pcm_data->hw_ptr);
 235
 236         return bytes_to_frames(runtime, pcm_data->hw_ptr);
 237 }
 238
 239 static int sst_byt_pcm_open(struct snd_pcm_substream *substream)
 240 {
 241         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 242         struct sst_byt_priv_data *pdata =
 243                 snd_soc_platform_get_drvdata(rtd->platform);
 244         struct sst_byt_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
 245         struct sst_byt *byt = pdata->byt;
 246
 247         dev_dbg(rtd->dev, "PCM: open\n");
 248
 249         pcm_data = &pdata->pcm[rtd->cpu_dai->id];
 250         mutex_lock(&pcm_data->mutex);
 251
 252         snd_soc_pcm_set_drvdata(rtd, pcm_data);
 253         pcm_data->substream = substream;
 254
 255         snd_soc_set_runtime_hwparams(substream, &sst_byt_pcm_hardware);
 256
 257         pcm_data->stream = sst_byt_stream_new(byt, rtd->cpu_dai->id + 1,
 258                                               byt_notify_pointer, pcm_data);
 259         if (pcm_data->stream == NULL) {
 260                 dev_err(rtd->dev, "failed to create stream\n");
 261                 mutex_unlock(&pcm_data->mutex);
 262                 return -EINVAL;
 263         }
 264
 265         mutex_unlock(&pcm_data->mutex);
 266         return 0;
 267 }
 268
 269 static int sst_byt_pcm_close(struct snd_pcm_substream *substream)
 270 {
 271         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 272         struct sst_byt_priv_data *pdata =
 273                 snd_soc_platform_get_drvdata(rtd->platform);
 274         struct sst_byt_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
 275         struct sst_byt *byt = pdata->byt;
 276         int ret;
 277
 278         dev_dbg(rtd->dev, "PCM: close\n");
 279
 280         mutex_lock(&pcm_data->mutex);
 281         ret = sst_byt_stream_free(byt, pcm_data->stream);
 282         if (ret < 0) {
 283                 dev_dbg(rtd->dev, "Free stream fail\n");
 284                 goto out;
 285         }
 286         pcm_data->stream = NULL;
 287
 288 out:
 289         mutex_unlock(&pcm_data->mutex);
 290         return ret;
 291 }
 292
 293 static int sst_byt_pcm_mmap(struct snd_pcm_substream *substream,
 294                             struct vm_area_struct *vma)
 295 {
 296         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 297
 298         dev_dbg(rtd->dev, "PCM: mmap\n");
 299         return snd_pcm_lib_default_mmap(substream, vma);
 300 }
 301
 302 static struct snd_pcm_ops sst_byt_pcm_ops = {
 303         .open           = sst_byt_pcm_open,
 304         .close          = sst_byt_pcm_close,
 305         .ioctl          = snd_pcm_lib_ioctl,
 306         .hw_params      = sst_byt_pcm_hw_params,
 307         .hw_free        = sst_byt_pcm_hw_free,
 308         .trigger        = sst_byt_pcm_trigger,
 309         .pointer        = sst_byt_pcm_pointer,
 310         .mmap           = sst_byt_pcm_mmap,
 311 };
 312
 313 static void sst_byt_pcm_free(struct snd_pcm *pcm)
 314 {
 315         snd_pcm_lib_preallocate_free_for_all(pcm);
 316 }
 317
 318 static int sst_byt_pcm_new(struct snd_soc_pcm_runtime *rtd)
 319 {
 320         struct snd_pcm *pcm = rtd->pcm;
 321         size_t size;
 322         struct snd_soc_platform *platform = rtd->platform;
 323         struct sst_pdata *pdata = dev_get_platdata(platform->dev);
 324         int ret = 0;
 325
 326         if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream ||
 327             pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
 328                 size = sst_byt_pcm_hardware.buffer_bytes_max;
 329                 ret = snd_pcm_lib_preallocate_pages_for_all(pcm,
 330                                                             SNDRV_DMA_TYPE_DEV,
 331                                                             pdata->dma_dev,
 332                                                             size, size);
 333                 if (ret) {
 334                         dev_err(rtd->dev, "dma buffer allocation failed %d\n",
 335                                 ret);
 336                         return ret;
 337                 }
 338         }
 339
 340         return ret;
 341 }
 342
 343 static struct snd_soc_dai_driver byt_dais[] = {
 344         {
 345                 .name  = "Front-cpu-dai",
 346                 .playback = {
 347                         .stream_name = "System Playback",
 348                         .channels_min = 2,
 349                         .channels_max = 2,
 350                         .rates = SNDRV_PCM_RATE_48000,
 351                         .formats = SNDRV_PCM_FMTBIT_S24_3LE |
 352                                    SNDRV_PCM_FMTBIT_S16_LE,
 353                 },
 354         },
 355         {
 356                 .name  = "Mic1-cpu-dai",
 357                 .capture = {
 358                         .stream_name = "Analog Capture",
 359                         .channels_min = 2,
 360                         .channels_max = 2,
 361                         .rates = SNDRV_PCM_RATE_48000,
 362                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 363                 },
 364         },
 365 };
 366
 367 static int sst_byt_pcm_probe(struct snd_soc_platform *platform)
 368 {
 369         struct sst_pdata *plat_data = dev_get_platdata(platform->dev);
 370         struct sst_byt_priv_data *priv_data;
 371         int i;
 372
 373         if (!plat_data)
 374                 return -ENODEV;
 375
 376         priv_data = devm_kzalloc(platform->dev, sizeof(*priv_data),
 377                                  GFP_KERNEL);
 378         priv_data->byt = plat_data->dsp;
 379         snd_soc_platform_set_drvdata(platform, priv_data);
 380
 381         for (i = 0; i < ARRAY_SIZE(byt_dais); i++) {
 382                 mutex_init(&priv_data->pcm[i].mutex);
 383                 INIT_WORK(&priv_data->pcm[i].work, sst_byt_pcm_work);
 384         }
 385
 386         return 0;
 387 }
 388
 389 static int sst_byt_pcm_remove(struct snd_soc_platform *platform)
 390 {
 391         return 0;
 392 }
 393
 394 static struct snd_soc_platform_driver byt_soc_platform = {
 395         .probe          = sst_byt_pcm_probe,
 396         .remove         = sst_byt_pcm_remove,
 397         .ops            = &sst_byt_pcm_ops,
 398         .pcm_new        = sst_byt_pcm_new,
 399         .pcm_free       = sst_byt_pcm_free,
 400 };
 401
 402 static const struct snd_soc_component_driver byt_dai_component = {
 403         .name           = "byt-dai",
 404 };
 405
 406 #ifdef CONFIG_PM
 407 static int sst_byt_pcm_dev_suspend_noirq(struct device *dev)
 408 {
 409         struct sst_pdata *sst_pdata = dev_get_platdata(dev);
 410         int ret;
 411
 412         dev_dbg(dev, "suspending noirq\n");
 413
 414         /* at this point all streams will be stopped and context saved */
 415         ret = sst_byt_dsp_suspend_noirq(dev, sst_pdata);
 416         if (ret < 0) {
 417                 dev_err(dev, "failed to suspend %d\n", ret);
 418                 return ret;
 419         }
 420
 421         return ret;
 422 }
 423
 424 static int sst_byt_pcm_dev_suspend_late(struct device *dev)
 425 {
 426         struct sst_pdata *sst_pdata = dev_get_platdata(dev);
 427         int ret;
 428
 429         dev_dbg(dev, "suspending late\n");
 430
 431         ret = sst_byt_dsp_suspend_late(dev, sst_pdata);
 432         if (ret < 0) {
 433                 dev_err(dev, "failed to suspend %d\n", ret);
 434                 return ret;
 435         }
 436
 437         return ret;
 438 }
 439
 440 static int sst_byt_pcm_dev_resume_early(struct device *dev)
 441 {
 442         struct sst_pdata *sst_pdata = dev_get_platdata(dev);
 443
 444         dev_dbg(dev, "resume early\n");
 445
 446         /* load fw and boot DSP */
 447         return sst_byt_dsp_boot(dev, sst_pdata);
 448 }
 449
 450 static int sst_byt_pcm_dev_resume(struct device *dev)
 451 {
 452         struct sst_pdata *sst_pdata = dev_get_platdata(dev);
 453
 454         dev_dbg(dev, "resume\n");
 455
 456         /* wait for FW to finish booting */
 457         return sst_byt_dsp_wait_for_ready(dev, sst_pdata);
 458 }
 459
 460 static const struct dev_pm_ops sst_byt_pm_ops = {
 461         .suspend_noirq = sst_byt_pcm_dev_suspend_noirq,
 462         .suspend_late = sst_byt_pcm_dev_suspend_late,
 463         .resume_early = sst_byt_pcm_dev_resume_early,
 464         .resume = sst_byt_pcm_dev_resume,
 465 };
 466
 467 #define SST_BYT_PM_OPS  (&sst_byt_pm_ops)
 468 #else
 469 #define SST_BYT_PM_OPS  NULL
 470 #endif
 471
 472 static int sst_byt_pcm_dev_probe(struct platform_device *pdev)
 473 {
 474         struct sst_pdata *sst_pdata = dev_get_platdata(&pdev->dev);
 475         int ret;
 476
 477         ret = sst_byt_dsp_init(&pdev->dev, sst_pdata);
 478         if (ret < 0)
 479                 return -ENODEV;
 480
 481         ret = snd_soc_register_platform(&pdev->dev, &byt_soc_platform);
 482         if (ret < 0)
 483                 goto err_plat;
 484
 485         ret = snd_soc_register_component(&pdev->dev, &byt_dai_component,
 486                                          byt_dais, ARRAY_SIZE(byt_dais));
 487         if (ret < 0)
 488                 goto err_comp;
 489
 490         return 0;
 491
 492 err_comp:
 493         snd_soc_unregister_platform(&pdev->dev);
 494 err_plat:
 495         sst_byt_dsp_free(&pdev->dev, sst_pdata);
 496         return ret;
 497 }
 498
 499 static int sst_byt_pcm_dev_remove(struct platform_device *pdev)
 500 {
 501         struct sst_pdata *sst_pdata = dev_get_platdata(&pdev->dev);
 502
 503         snd_soc_unregister_platform(&pdev->dev);
 504         snd_soc_unregister_component(&pdev->dev);
 505         sst_byt_dsp_free(&pdev->dev, sst_pdata);
 506
 507         return 0;
 508 }
 509
 510 static struct platform_driver sst_byt_pcm_driver = {
 511         .driver = {
 512                 .name = "baytrail-pcm-audio",
 513                 .owner = THIS_MODULE,
 514                 .pm = SST_BYT_PM_OPS,
 515         },
 516
 517         .probe = sst_byt_pcm_dev_probe,
 518         .remove = sst_byt_pcm_dev_remove,
 519 };
 520 module_platform_driver(sst_byt_pcm_driver);
 521
 522 MODULE_AUTHOR("Jarkko Nikula");
 523 MODULE_DESCRIPTION("Baytrail PCM");
 524 MODULE_LICENSE("GPL v2");
 525 MODULE_ALIAS("platform:baytrail-pcm-audio");