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_FMTBIT_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         /* flag indicating is stream context restore needed after suspend */
  64         bool restore_stream;
  65 };
  66
  67 /* this may get called several times by oss emulation */
  68 static int sst_byt_pcm_hw_params(struct snd_pcm_substream *substream,
  69                                  struct snd_pcm_hw_params *params)
  70 {
  71         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  72         struct sst_byt_priv_data *pdata =
  73                 snd_soc_platform_get_drvdata(rtd->platform);
  74         struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];
  75         struct sst_byt *byt = pdata->byt;
  76         u32 rate, bits;
  77         u8 channels;
  78         int ret, playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
  79
  80         dev_dbg(rtd->dev, "PCM: hw_params, pcm_data %p\n", pcm_data);
  81
  82         ret = sst_byt_stream_type(byt, pcm_data->stream,
  83                                   1, 1, !playback);
  84         if (ret < 0) {
  85                 dev_err(rtd->dev, "failed to set stream format %d\n", ret);
  86                 return ret;
  87         }
  88
  89         rate = params_rate(params);
  90         ret = sst_byt_stream_set_rate(byt, pcm_data->stream, rate);
  91         if (ret < 0) {
  92                 dev_err(rtd->dev, "could not set rate %d\n", rate);
  93                 return ret;
  94         }
  95
  96         bits = snd_pcm_format_width(params_format(params));
  97         ret = sst_byt_stream_set_bits(byt, pcm_data->stream, bits);
  98         if (ret < 0) {
  99                 dev_err(rtd->dev, "could not set formats %d\n",
 100                         params_rate(params));
 101                 return ret;
 102         }
 103
 104         channels = (u8)(params_channels(params) & 0xF);
 105         ret = sst_byt_stream_set_channels(byt, pcm_data->stream, channels);
 106         if (ret < 0) {
 107                 dev_err(rtd->dev, "could not set channels %d\n",
 108                         params_rate(params));
 109                 return ret;
 110         }
 111
 112         snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
 113
 114         ret = sst_byt_stream_buffer(byt, pcm_data->stream,
 115                                     substream->dma_buffer.addr,
 116                                     params_buffer_bytes(params));
 117         if (ret < 0) {
 118                 dev_err(rtd->dev, "PCM: failed to set DMA buffer %d\n", ret);
 119                 return ret;
 120         }
 121
 122         ret = sst_byt_stream_commit(byt, pcm_data->stream);
 123         if (ret < 0) {
 124                 dev_err(rtd->dev, "PCM: failed stream commit %d\n", ret);
 125                 return ret;
 126         }
 127
 128         return 0;
 129 }
 130
 131 static int sst_byt_pcm_hw_free(struct snd_pcm_substream *substream)
 132 {
 133         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 134
 135         dev_dbg(rtd->dev, "PCM: hw_free\n");
 136         snd_pcm_lib_free_pages(substream);
 137
 138         return 0;
 139 }
 140
 141 static int sst_byt_pcm_restore_stream_context(struct snd_pcm_substream *substream)
 142 {
 143         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 144         struct sst_byt_priv_data *pdata =
 145                 snd_soc_platform_get_drvdata(rtd->platform);
 146         struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];
 147         struct sst_byt *byt = pdata->byt;
 148         int ret;
 149
 150         /* commit stream using existing stream params */
 151         ret = sst_byt_stream_commit(byt, pcm_data->stream);
 152         if (ret < 0) {
 153                 dev_err(rtd->dev, "PCM: failed stream commit %d\n", ret);
 154                 return ret;
 155         }
 156
 157         sst_byt_stream_start(byt, pcm_data->stream, pcm_data->hw_ptr);
 158
 159         dev_dbg(rtd->dev, "stream context restored at offset %d\n",
 160                 pcm_data->hw_ptr);
 161
 162         return 0;
 163 }
 164
 165 static void sst_byt_pcm_work(struct work_struct *work)
 166 {
 167         struct sst_byt_pcm_data *pcm_data =
 168                 container_of(work, struct sst_byt_pcm_data, work);
 169
 170         if (snd_pcm_running(pcm_data->substream))
 171                 sst_byt_pcm_restore_stream_context(pcm_data->substream);
 172 }
 173
 174 static int sst_byt_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 175 {
 176         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 177         struct sst_byt_priv_data *pdata =
 178                 snd_soc_platform_get_drvdata(rtd->platform);
 179         struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];
 180         struct sst_byt *byt = pdata->byt;
 181
 182         dev_dbg(rtd->dev, "PCM: trigger %d\n", cmd);
 183
 184         switch (cmd) {
 185         case SNDRV_PCM_TRIGGER_START:
 186                 pcm_data->hw_ptr = 0;
 187                 sst_byt_stream_start(byt, pcm_data->stream, 0);
 188                 break;
 189         case SNDRV_PCM_TRIGGER_RESUME:
 190                 if (pdata->restore_stream == true)
 191                         schedule_work(&pcm_data->work);
 192                 else
 193                         sst_byt_stream_resume(byt, pcm_data->stream);
 194                 break;
 195         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 196                 sst_byt_stream_resume(byt, pcm_data->stream);
 197                 break;
 198         case SNDRV_PCM_TRIGGER_STOP:
 199                 sst_byt_stream_stop(byt, pcm_data->stream);
 200                 break;
 201         case SNDRV_PCM_TRIGGER_SUSPEND:
 202                 pdata->restore_stream = false;
 203         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 204                 sst_byt_stream_pause(byt, pcm_data->stream);
 205                 break;
 206         default:
 207                 break;
 208         }
 209
 210         return 0;
 211 }
 212
 213 static u32 byt_notify_pointer(struct sst_byt_stream *stream, void *data)
 214 {
 215         struct sst_byt_pcm_data *pcm_data = data;
 216         struct snd_pcm_substream *substream = pcm_data->substream;
 217         struct snd_pcm_runtime *runtime = substream->runtime;
 218         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 219         struct sst_byt_priv_data *pdata =
 220                 snd_soc_platform_get_drvdata(rtd->platform);
 221         struct sst_byt *byt = pdata->byt;
 222         u32 pos, hw_pos;
 223
 224         hw_pos = sst_byt_get_dsp_position(byt, pcm_data->stream,
 225                                           snd_pcm_lib_buffer_bytes(substream));
 226         pcm_data->hw_ptr = hw_pos;
 227         pos = frames_to_bytes(runtime,
 228                               (runtime->control->appl_ptr %
 229                                runtime->buffer_size));
 230
 231         dev_dbg(rtd->dev, "PCM: App/DMA pointer %u/%u bytes\n", pos, hw_pos);
 232
 233         snd_pcm_period_elapsed(substream);
 234         return pos;
 235 }
 236
 237 static snd_pcm_uframes_t sst_byt_pcm_pointer(struct snd_pcm_substream *substream)
 238 {
 239         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 240         struct snd_pcm_runtime *runtime = substream->runtime;
 241         struct sst_byt_priv_data *pdata =
 242                 snd_soc_platform_get_drvdata(rtd->platform);
 243         struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];
 244
 245         dev_dbg(rtd->dev, "PCM: DMA pointer %u bytes\n", pcm_data->hw_ptr);
 246
 247         return bytes_to_frames(runtime, pcm_data->hw_ptr);
 248 }
 249
 250 static int sst_byt_pcm_open(struct snd_pcm_substream *substream)
 251 {
 252         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 253         struct sst_byt_priv_data *pdata =
 254                 snd_soc_platform_get_drvdata(rtd->platform);
 255         struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];
 256         struct sst_byt *byt = pdata->byt;
 257
 258         dev_dbg(rtd->dev, "PCM: open\n");
 259
 260         mutex_lock(&pcm_data->mutex);
 261
 262         pcm_data->substream = substream;
 263
 264         snd_soc_set_runtime_hwparams(substream, &sst_byt_pcm_hardware);
 265
 266         pcm_data->stream = sst_byt_stream_new(byt, substream->stream + 1,
 267                                               byt_notify_pointer, pcm_data);
 268         if (pcm_data->stream == NULL) {
 269                 dev_err(rtd->dev, "failed to create stream\n");
 270                 mutex_unlock(&pcm_data->mutex);
 271                 return -EINVAL;
 272         }
 273
 274         mutex_unlock(&pcm_data->mutex);
 275         return 0;
 276 }
 277
 278 static int sst_byt_pcm_close(struct snd_pcm_substream *substream)
 279 {
 280         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 281         struct sst_byt_priv_data *pdata =
 282                 snd_soc_platform_get_drvdata(rtd->platform);
 283         struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];
 284         struct sst_byt *byt = pdata->byt;
 285         int ret;
 286
 287         dev_dbg(rtd->dev, "PCM: close\n");
 288
 289         cancel_work_sync(&pcm_data->work);
 290         mutex_lock(&pcm_data->mutex);
 291         ret = sst_byt_stream_free(byt, pcm_data->stream);
 292         if (ret < 0) {
 293                 dev_dbg(rtd->dev, "Free stream fail\n");
 294                 goto out;
 295         }
 296         pcm_data->stream = NULL;
 297
 298 out:
 299         mutex_unlock(&pcm_data->mutex);
 300         return ret;
 301 }
 302
 303 static int sst_byt_pcm_mmap(struct snd_pcm_substream *substream,
 304                             struct vm_area_struct *vma)
 305 {
 306         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 307
 308         dev_dbg(rtd->dev, "PCM: mmap\n");
 309         return snd_pcm_lib_default_mmap(substream, vma);
 310 }
 311
 312 static struct snd_pcm_ops sst_byt_pcm_ops = {
 313         .open           = sst_byt_pcm_open,
 314         .close          = sst_byt_pcm_close,
 315         .ioctl          = snd_pcm_lib_ioctl,
 316         .hw_params      = sst_byt_pcm_hw_params,
 317         .hw_free        = sst_byt_pcm_hw_free,
 318         .trigger        = sst_byt_pcm_trigger,
 319         .pointer        = sst_byt_pcm_pointer,
 320         .mmap           = sst_byt_pcm_mmap,
 321 };
 322
 323 static void sst_byt_pcm_free(struct snd_pcm *pcm)
 324 {
 325         snd_pcm_lib_preallocate_free_for_all(pcm);
 326 }
 327
 328 static int sst_byt_pcm_new(struct snd_soc_pcm_runtime *rtd)
 329 {
 330         struct snd_pcm *pcm = rtd->pcm;
 331         size_t size;
 332         struct snd_soc_platform *platform = rtd->platform;
 333         struct sst_pdata *pdata = dev_get_platdata(platform->dev);
 334         int ret = 0;
 335
 336         if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream ||
 337             pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
 338                 size = sst_byt_pcm_hardware.buffer_bytes_max;
 339                 ret = snd_pcm_lib_preallocate_pages_for_all(pcm,
 340                                                             SNDRV_DMA_TYPE_DEV,
 341                                                             pdata->dma_dev,
 342                                                             size, size);
 343                 if (ret) {
 344                         dev_err(rtd->dev, "dma buffer allocation failed %d\n",
 345                                 ret);
 346                         return ret;
 347                 }
 348         }
 349
 350         return ret;
 351 }
 352
 353 static struct snd_soc_dai_driver byt_dais[] = {
 354         {
 355                 .name  = "Baytrail PCM",
 356                 .playback = {
 357                         .stream_name = "System Playback",
 358                         .channels_min = 2,
 359                         .channels_max = 2,
 360                         .rates = SNDRV_PCM_RATE_48000,
 361                         .formats = SNDRV_PCM_FMTBIT_S24_3LE |
 362                                    SNDRV_PCM_FMTBIT_S16_LE,
 363                 },
 364                 .capture = {
 365                         .stream_name = "Analog Capture",
 366                         .channels_min = 2,
 367                         .channels_max = 2,
 368                         .rates = SNDRV_PCM_RATE_48000,
 369                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 370                 },
 371         },
 372 };
 373
 374 static int sst_byt_pcm_probe(struct snd_soc_platform *platform)
 375 {
 376         struct sst_pdata *plat_data = dev_get_platdata(platform->dev);
 377         struct sst_byt_priv_data *priv_data;
 378         int i;
 379
 380         if (!plat_data)
 381                 return -ENODEV;
 382
 383         priv_data = devm_kzalloc(platform->dev, sizeof(*priv_data),
 384                                  GFP_KERNEL);
 385         priv_data->byt = plat_data->dsp;
 386         snd_soc_platform_set_drvdata(platform, priv_data);
 387
 388         for (i = 0; i < BYT_PCM_COUNT; i++) {
 389                 mutex_init(&priv_data->pcm[i].mutex);
 390                 INIT_WORK(&priv_data->pcm[i].work, sst_byt_pcm_work);
 391         }
 392
 393         return 0;
 394 }
 395
 396 static int sst_byt_pcm_remove(struct snd_soc_platform *platform)
 397 {
 398         return 0;
 399 }
 400
 401 static struct snd_soc_platform_driver byt_soc_platform = {
 402         .probe          = sst_byt_pcm_probe,
 403         .remove         = sst_byt_pcm_remove,
 404         .ops            = &sst_byt_pcm_ops,
 405         .pcm_new        = sst_byt_pcm_new,
 406         .pcm_free       = sst_byt_pcm_free,
 407 };
 408
 409 static const struct snd_soc_component_driver byt_dai_component = {
 410         .name           = "byt-dai",
 411 };
 412
 413 #ifdef CONFIG_PM
 414 static int sst_byt_pcm_dev_suspend_late(struct device *dev)
 415 {
 416         struct sst_pdata *sst_pdata = dev_get_platdata(dev);
 417         struct sst_byt_priv_data *priv_data = dev_get_drvdata(dev);
 418         int ret;
 419
 420         dev_dbg(dev, "suspending late\n");
 421
 422         ret = sst_byt_dsp_suspend_late(dev, sst_pdata);
 423         if (ret < 0) {
 424                 dev_err(dev, "failed to suspend %d\n", ret);
 425                 return ret;
 426         }
 427
 428         priv_data->restore_stream = true;
 429
 430         return ret;
 431 }
 432
 433 static int sst_byt_pcm_dev_resume_early(struct device *dev)
 434 {
 435         struct sst_pdata *sst_pdata = dev_get_platdata(dev);
 436         int ret;
 437
 438         dev_dbg(dev, "resume early\n");
 439
 440         /* load fw and boot DSP */
 441         ret = sst_byt_dsp_boot(dev, sst_pdata);
 442         if (ret)
 443                 return ret;
 444
 445         /* wait for FW to finish booting */
 446         return sst_byt_dsp_wait_for_ready(dev, sst_pdata);
 447 }
 448
 449 static const struct dev_pm_ops sst_byt_pm_ops = {
 450         .suspend_late = sst_byt_pcm_dev_suspend_late,
 451         .resume_early = sst_byt_pcm_dev_resume_early,
 452 };
 453
 454 #define SST_BYT_PM_OPS  (&sst_byt_pm_ops)
 455 #else
 456 #define SST_BYT_PM_OPS  NULL
 457 #endif
 458
 459 static int sst_byt_pcm_dev_probe(struct platform_device *pdev)
 460 {
 461         struct sst_pdata *sst_pdata = dev_get_platdata(&pdev->dev);
 462         int ret;
 463
 464         ret = sst_byt_dsp_init(&pdev->dev, sst_pdata);
 465         if (ret < 0)
 466                 return -ENODEV;
 467
 468         ret = snd_soc_register_platform(&pdev->dev, &byt_soc_platform);
 469         if (ret < 0)
 470                 goto err_plat;
 471
 472         ret = snd_soc_register_component(&pdev->dev, &byt_dai_component,
 473                                          byt_dais, ARRAY_SIZE(byt_dais));
 474         if (ret < 0)
 475                 goto err_comp;
 476
 477         return 0;
 478
 479 err_comp:
 480         snd_soc_unregister_platform(&pdev->dev);
 481 err_plat:
 482         sst_byt_dsp_free(&pdev->dev, sst_pdata);
 483         return ret;
 484 }
 485
 486 static int sst_byt_pcm_dev_remove(struct platform_device *pdev)
 487 {
 488         struct sst_pdata *sst_pdata = dev_get_platdata(&pdev->dev);
 489
 490         snd_soc_unregister_platform(&pdev->dev);
 491         snd_soc_unregister_component(&pdev->dev);
 492         sst_byt_dsp_free(&pdev->dev, sst_pdata);
 493
 494         return 0;
 495 }
 496
 497 static struct platform_driver sst_byt_pcm_driver = {
 498         .driver = {
 499                 .name = "baytrail-pcm-audio",
 500                 .pm = SST_BYT_PM_OPS,
 501         },
 502
 503         .probe = sst_byt_pcm_dev_probe,
 504         .remove = sst_byt_pcm_dev_remove,
 505 };
 506 module_platform_driver(sst_byt_pcm_driver);
 507
 508 MODULE_AUTHOR("Jarkko Nikula");
 509 MODULE_DESCRIPTION("Baytrail PCM");
 510 MODULE_LICENSE("GPL v2");
 511 MODULE_ALIAS("platform:baytrail-pcm-audio");