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

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