sound/soc/intel/skylake/skl-pcm.c

   1 /*
   2  *  skl-pcm.c -ASoC HDA Platform driver file implementing PCM functionality
   3  *
   4  *  Copyright (C) 2014-2015 Intel Corp
   5  *  Author:  Jeeja KP <jeeja.kp@intel.com>
   6  *
   7  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   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 as published by
  11  *  the Free Software Foundation; version 2 of the License.
  12  *
  13  *  This program is distributed in the hope that it will be useful, but
  14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  General Public License for more details.
  17  *
  18  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  19  *
  20  */
  21
  22 #include <linux/pci.h>
  23 #include <linux/pm_runtime.h>
  24 #include <sound/pcm_params.h>
  25 #include <sound/soc.h>
  26 #include "skl.h"
  27 #include "skl-topology.h"
  28
  29 #define HDA_MONO 1
  30 #define HDA_STEREO 2
  31
  32 static struct snd_pcm_hardware azx_pcm_hw = {
  33         .info =                 (SNDRV_PCM_INFO_MMAP |
  34                                  SNDRV_PCM_INFO_INTERLEAVED |
  35                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
  36                                  SNDRV_PCM_INFO_MMAP_VALID |
  37                                  SNDRV_PCM_INFO_PAUSE |
  38                                  SNDRV_PCM_INFO_SYNC_START |
  39                                  SNDRV_PCM_INFO_HAS_WALL_CLOCK | /* legacy */
  40                                  SNDRV_PCM_INFO_HAS_LINK_ATIME |
  41                                  SNDRV_PCM_INFO_NO_PERIOD_WAKEUP),
  42         .formats =              SNDRV_PCM_FMTBIT_S16_LE,
  43         .rates =                SNDRV_PCM_RATE_48000,
  44         .rate_min =             48000,
  45         .rate_max =             48000,
  46         .channels_min =         2,
  47         .channels_max =         2,
  48         .buffer_bytes_max =     AZX_MAX_BUF_SIZE,
  49         .period_bytes_min =     128,
  50         .period_bytes_max =     AZX_MAX_BUF_SIZE / 2,
  51         .periods_min =          2,
  52         .periods_max =          AZX_MAX_FRAG,
  53         .fifo_size =            0,
  54 };
  55
  56 static inline
  57 struct hdac_ext_stream *get_hdac_ext_stream(struct snd_pcm_substream *substream)
  58 {
  59         return substream->runtime->private_data;
  60 }
  61
  62 static struct hdac_ext_bus *get_bus_ctx(struct snd_pcm_substream *substream)
  63 {
  64         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
  65         struct hdac_stream *hstream = hdac_stream(stream);
  66         struct hdac_bus *bus = hstream->bus;
  67
  68         return hbus_to_ebus(bus);
  69 }
  70
  71 static int skl_substream_alloc_pages(struct hdac_ext_bus *ebus,
  72                                  struct snd_pcm_substream *substream,
  73                                  size_t size)
  74 {
  75         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
  76
  77         hdac_stream(stream)->bufsize = 0;
  78         hdac_stream(stream)->period_bytes = 0;
  79         hdac_stream(stream)->format_val = 0;
  80
  81         return snd_pcm_lib_malloc_pages(substream, size);
  82 }
  83
  84 static int skl_substream_free_pages(struct hdac_bus *bus,
  85                                 struct snd_pcm_substream *substream)
  86 {
  87         return snd_pcm_lib_free_pages(substream);
  88 }
  89
  90 static void skl_set_pcm_constrains(struct hdac_ext_bus *ebus,
  91                                  struct snd_pcm_runtime *runtime)
  92 {
  93         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
  94
  95         /* avoid wrap-around with wall-clock */
  96         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_TIME,
  97                                      20, 178000000);
  98 }
  99
 100 static enum hdac_ext_stream_type skl_get_host_stream_type(struct hdac_ext_bus *ebus)
 101 {
 102         if (ebus->ppcap)
 103                 return HDAC_EXT_STREAM_TYPE_HOST;
 104         else
 105                 return HDAC_EXT_STREAM_TYPE_COUPLED;
 106 }
 107
 108 static int skl_pcm_open(struct snd_pcm_substream *substream,
 109                 struct snd_soc_dai *dai)
 110 {
 111         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 112         struct hdac_ext_stream *stream;
 113         struct snd_pcm_runtime *runtime = substream->runtime;
 114         struct skl_dma_params *dma_params;
 115         int ret;
 116
 117         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
 118         ret = pm_runtime_get_sync(dai->dev);
 119         if (ret < 0)
 120                 return ret;
 121
 122         stream = snd_hdac_ext_stream_assign(ebus, substream,
 123                                         skl_get_host_stream_type(ebus));
 124         if (stream == NULL)
 125                 return -EBUSY;
 126
 127         skl_set_pcm_constrains(ebus, runtime);
 128
 129         /*
 130          * disable WALLCLOCK timestamps for capture streams
 131          * until we figure out how to handle digital inputs
 132          */
 133         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
 134                 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_WALL_CLOCK; /* legacy */
 135                 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_LINK_ATIME;
 136         }
 137
 138         runtime->private_data = stream;
 139
 140         dma_params = kzalloc(sizeof(*dma_params), GFP_KERNEL);
 141         if (!dma_params)
 142                 return -ENOMEM;
 143
 144         dma_params->stream_tag = hdac_stream(stream)->stream_tag;
 145         snd_soc_dai_set_dma_data(dai, substream, dma_params);
 146
 147         dev_dbg(dai->dev, "stream tag set in dma params=%d\n",
 148                                  dma_params->stream_tag);
 149         snd_pcm_set_sync(substream);
 150
 151         return 0;
 152 }
 153
 154 static int skl_get_format(struct snd_pcm_substream *substream,
 155                 struct snd_soc_dai *dai)
 156 {
 157         struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 158         struct skl_dma_params *dma_params;
 159         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 160         int format_val = 0;
 161
 162         if (ebus->ppcap) {
 163                 struct snd_pcm_runtime *runtime = substream->runtime;
 164
 165                 format_val = snd_hdac_calc_stream_format(runtime->rate,
 166                                                 runtime->channels,
 167                                                 runtime->format,
 168                                                 32, 0);
 169         } else {
 170                 struct snd_soc_dai *codec_dai = rtd->codec_dai;
 171
 172                 dma_params = snd_soc_dai_get_dma_data(codec_dai, substream);
 173                 if (dma_params)
 174                         format_val = dma_params->format;
 175         }
 176
 177         return format_val;
 178 }
 179
 180 static int skl_pcm_prepare(struct snd_pcm_substream *substream,
 181                 struct snd_soc_dai *dai)
 182 {
 183         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
 184         unsigned int format_val;
 185         int err;
 186
 187         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
 188         if (hdac_stream(stream)->prepared) {
 189                 dev_dbg(dai->dev, "already stream is prepared - returning\n");
 190                 return 0;
 191         }
 192
 193         format_val = skl_get_format(substream, dai);
 194         dev_dbg(dai->dev, "stream_tag=%d formatvalue=%d\n",
 195                                 hdac_stream(stream)->stream_tag, format_val);
 196         snd_hdac_stream_reset(hdac_stream(stream));
 197
 198         err = snd_hdac_stream_set_params(hdac_stream(stream), format_val);
 199         if (err < 0)
 200                 return err;
 201
 202         err = snd_hdac_stream_setup(hdac_stream(stream));
 203         if (err < 0)
 204                 return err;
 205
 206         hdac_stream(stream)->prepared = 1;
 207
 208         return err;
 209 }
 210
 211 static int skl_pcm_hw_params(struct snd_pcm_substream *substream,
 212                                 struct snd_pcm_hw_params *params,
 213                                 struct snd_soc_dai *dai)
 214 {
 215         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 216         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
 217         struct snd_pcm_runtime *runtime = substream->runtime;
 218         struct skl_pipe_params p_params = {0};
 219         struct skl_module_cfg *m_cfg;
 220         int ret, dma_id;
 221
 222         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
 223         ret = skl_substream_alloc_pages(ebus, substream,
 224                                           params_buffer_bytes(params));
 225         if (ret < 0)
 226                 return ret;
 227
 228         dev_dbg(dai->dev, "format_val, rate=%d, ch=%d, format=%d\n",
 229                         runtime->rate, runtime->channels, runtime->format);
 230
 231         dma_id = hdac_stream(stream)->stream_tag - 1;
 232         dev_dbg(dai->dev, "dma_id=%d\n", dma_id);
 233
 234         p_params.s_fmt = snd_pcm_format_width(params_format(params));
 235         p_params.ch = params_channels(params);
 236         p_params.s_freq = params_rate(params);
 237         p_params.host_dma_id = dma_id;
 238         p_params.stream = substream->stream;
 239
 240         m_cfg = skl_tplg_fe_get_cpr_module(dai, p_params.stream);
 241         if (m_cfg)
 242                 skl_tplg_update_pipe_params(dai->dev, m_cfg, &p_params);
 243
 244         return 0;
 245 }
 246
 247 static void skl_pcm_close(struct snd_pcm_substream *substream,
 248                 struct snd_soc_dai *dai)
 249 {
 250         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
 251         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 252         struct skl_dma_params *dma_params = NULL;
 253
 254         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
 255
 256         snd_hdac_ext_stream_release(stream, skl_get_host_stream_type(ebus));
 257
 258         dma_params = snd_soc_dai_get_dma_data(dai, substream);
 259         /*
 260          * now we should set this to NULL as we are freeing by the
 261          * dma_params
 262          */
 263         snd_soc_dai_set_dma_data(dai, substream, NULL);
 264
 265         pm_runtime_mark_last_busy(dai->dev);
 266         pm_runtime_put_autosuspend(dai->dev);
 267         kfree(dma_params);
 268 }
 269
 270 static int skl_pcm_hw_free(struct snd_pcm_substream *substream,
 271                 struct snd_soc_dai *dai)
 272 {
 273         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 274         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
 275
 276         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
 277
 278         snd_hdac_stream_cleanup(hdac_stream(stream));
 279         hdac_stream(stream)->prepared = 0;
 280
 281         return skl_substream_free_pages(ebus_to_hbus(ebus), substream);
 282 }
 283
 284 static int skl_be_hw_params(struct snd_pcm_substream *substream,
 285                                 struct snd_pcm_hw_params *params,
 286                                 struct snd_soc_dai *dai)
 287 {
 288         struct skl_pipe_params p_params = {0};
 289
 290         p_params.s_fmt = snd_pcm_format_width(params_format(params));
 291         p_params.ch = params_channels(params);
 292         p_params.s_freq = params_rate(params);
 293         p_params.stream = substream->stream;
 294         skl_tplg_be_update_params(dai, &p_params);
 295
 296         return 0;
 297 }
 298
 299 static int skl_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
 300                 struct snd_soc_dai *dai)
 301 {
 302         struct skl *skl = get_skl_ctx(dai->dev);
 303         struct skl_sst *ctx = skl->skl_sst;
 304         struct skl_module_cfg *mconfig;
 305
 306         mconfig = skl_tplg_fe_get_cpr_module(dai, substream->stream);
 307         if (!mconfig)
 308                 return -EIO;
 309
 310         switch (cmd) {
 311         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 312         case SNDRV_PCM_TRIGGER_RESUME:
 313                 return skl_run_pipe(ctx, mconfig->pipe);
 314
 315         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 316         case SNDRV_PCM_TRIGGER_SUSPEND:
 317                 return skl_stop_pipe(ctx, mconfig->pipe);
 318
 319         default:
 320                 return 0;
 321         }
 322 }
 323
 324 static int skl_link_hw_params(struct snd_pcm_substream *substream,
 325                                 struct snd_pcm_hw_params *params,
 326                                 struct snd_soc_dai *dai)
 327 {
 328         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 329         struct hdac_ext_stream *link_dev;
 330         struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 331         struct skl_dma_params *dma_params;
 332         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 333         struct skl_pipe_params p_params = {0};
 334
 335         link_dev = snd_hdac_ext_stream_assign(ebus, substream,
 336                                         HDAC_EXT_STREAM_TYPE_LINK);
 337         if (!link_dev)
 338                 return -EBUSY;
 339
 340         snd_soc_dai_set_dma_data(dai, substream, (void *)link_dev);
 341
 342         /* set the stream tag in the codec dai dma params  */
 343         dma_params = (struct skl_dma_params *)
 344                         snd_soc_dai_get_dma_data(codec_dai, substream);
 345         if (dma_params)
 346                 dma_params->stream_tag =  hdac_stream(link_dev)->stream_tag;
 347         snd_soc_dai_set_dma_data(codec_dai, substream, (void *)dma_params);
 348
 349         p_params.s_fmt = snd_pcm_format_width(params_format(params));
 350         p_params.ch = params_channels(params);
 351         p_params.s_freq = params_rate(params);
 352         p_params.stream = substream->stream;
 353         p_params.link_dma_id = hdac_stream(link_dev)->stream_tag - 1;
 354
 355         skl_tplg_be_update_params(dai, &p_params);
 356
 357         return 0;
 358 }
 359
 360 static int skl_link_pcm_prepare(struct snd_pcm_substream *substream,
 361                 struct snd_soc_dai *dai)
 362 {
 363         struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 364         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 365         struct hdac_ext_stream *link_dev =
 366                         snd_soc_dai_get_dma_data(dai, substream);
 367         unsigned int format_val = 0;
 368         struct skl_dma_params *dma_params;
 369         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 370         struct hdac_ext_link *link;
 371
 372         if (link_dev->link_prepared) {
 373                 dev_dbg(dai->dev, "already stream is prepared - returning\n");
 374                 return 0;
 375         }
 376
 377         dma_params  = (struct skl_dma_params *)
 378                         snd_soc_dai_get_dma_data(codec_dai, substream);
 379         if (dma_params)
 380                 format_val = dma_params->format;
 381         dev_dbg(dai->dev, "stream_tag=%d formatvalue=%d codec_dai_name=%s\n",
 382                         hdac_stream(link_dev)->stream_tag, format_val, codec_dai->name);
 383
 384         snd_hdac_ext_link_stream_reset(link_dev);
 385
 386         snd_hdac_ext_link_stream_setup(link_dev, format_val);
 387
 388         link = snd_hdac_ext_bus_get_link(ebus, rtd->codec->component.name);
 389         if (!link)
 390                 return -EINVAL;
 391
 392         snd_hdac_ext_link_set_stream_id(link, hdac_stream(link_dev)->stream_tag);
 393         link_dev->link_prepared = 1;
 394
 395         return 0;
 396 }
 397
 398 static int skl_link_pcm_trigger(struct snd_pcm_substream *substream,
 399         int cmd, struct snd_soc_dai *dai)
 400 {
 401         struct hdac_ext_stream *link_dev =
 402                                 snd_soc_dai_get_dma_data(dai, substream);
 403
 404         dev_dbg(dai->dev, "In %s cmd=%d\n", __func__, cmd);
 405         switch (cmd) {
 406         case SNDRV_PCM_TRIGGER_START:
 407         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 408         case SNDRV_PCM_TRIGGER_RESUME:
 409                 snd_hdac_ext_link_stream_start(link_dev);
 410                 break;
 411
 412         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 413         case SNDRV_PCM_TRIGGER_SUSPEND:
 414         case SNDRV_PCM_TRIGGER_STOP:
 415                 snd_hdac_ext_link_stream_clear(link_dev);
 416                 break;
 417
 418         default:
 419                 return -EINVAL;
 420         }
 421         return 0;
 422 }
 423
 424 static int skl_link_hw_free(struct snd_pcm_substream *substream,
 425                 struct snd_soc_dai *dai)
 426 {
 427         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 428         struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 429         struct hdac_ext_stream *link_dev =
 430                                 snd_soc_dai_get_dma_data(dai, substream);
 431         struct hdac_ext_link *link;
 432
 433         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
 434
 435         link_dev->link_prepared = 0;
 436
 437         link = snd_hdac_ext_bus_get_link(ebus, rtd->codec->component.name);
 438         if (!link)
 439                 return -EINVAL;
 440
 441         snd_hdac_ext_link_clear_stream_id(link, hdac_stream(link_dev)->stream_tag);
 442         snd_hdac_ext_stream_release(link_dev, HDAC_EXT_STREAM_TYPE_LINK);
 443         return 0;
 444 }
 445
 446 static int skl_be_startup(struct snd_pcm_substream *substream,
 447                 struct snd_soc_dai *dai)
 448 {
 449         return pm_runtime_get_sync(dai->dev);
 450 }
 451
 452 static void skl_be_shutdown(struct snd_pcm_substream *substream,
 453                 struct snd_soc_dai *dai)
 454 {
 455         pm_runtime_mark_last_busy(dai->dev);
 456         pm_runtime_put_autosuspend(dai->dev);
 457 }
 458
 459 static struct snd_soc_dai_ops skl_pcm_dai_ops = {
 460         .startup = skl_pcm_open,
 461         .shutdown = skl_pcm_close,
 462         .prepare = skl_pcm_prepare,
 463         .hw_params = skl_pcm_hw_params,
 464         .hw_free = skl_pcm_hw_free,
 465         .trigger = skl_pcm_trigger,
 466 };
 467
 468 static struct snd_soc_dai_ops skl_dmic_dai_ops = {
 469         .startup = skl_be_startup,
 470         .hw_params = skl_be_hw_params,
 471         .shutdown = skl_be_shutdown,
 472 };
 473
 474 static struct snd_soc_dai_ops skl_be_ssp_dai_ops = {
 475         .startup = skl_be_startup,
 476         .hw_params = skl_be_hw_params,
 477         .shutdown = skl_be_shutdown,
 478 };
 479
 480 static struct snd_soc_dai_ops skl_link_dai_ops = {
 481         .startup = skl_be_startup,
 482         .prepare = skl_link_pcm_prepare,
 483         .hw_params = skl_link_hw_params,
 484         .hw_free = skl_link_hw_free,
 485         .trigger = skl_link_pcm_trigger,
 486         .shutdown = skl_be_shutdown,
 487 };
 488
 489 static struct snd_soc_dai_driver skl_platform_dai[] = {
 490 {
 491         .name = "System Pin",
 492         .ops = &skl_pcm_dai_ops,
 493         .playback = {
 494                 .stream_name = "System Playback",
 495                 .channels_min = HDA_MONO,
 496                 .channels_max = HDA_STEREO,
 497                 .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_8000,
 498                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 499         },
 500         .capture = {
 501                 .stream_name = "System Capture",
 502                 .channels_min = HDA_MONO,
 503                 .channels_max = HDA_STEREO,
 504                 .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_16000,
 505                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 506         },
 507 },
 508 {
 509         .name = "Reference Pin",
 510         .ops = &skl_pcm_dai_ops,
 511         .capture = {
 512                 .stream_name = "Reference Capture",
 513                 .channels_min = HDA_MONO,
 514                 .channels_max = HDA_STEREO,
 515                 .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_16000,
 516                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 517         },
 518 },
 519 {
 520         .name = "Deepbuffer Pin",
 521         .ops = &skl_pcm_dai_ops,
 522         .playback = {
 523                 .stream_name = "Deepbuffer Playback",
 524                 .channels_min = HDA_STEREO,
 525                 .channels_max = HDA_STEREO,
 526                 .rates = SNDRV_PCM_RATE_48000,
 527                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 528         },
 529 },
 530 {
 531         .name = "LowLatency Pin",
 532         .ops = &skl_pcm_dai_ops,
 533         .playback = {
 534                 .stream_name = "Low Latency Playback",
 535                 .channels_min = HDA_STEREO,
 536                 .channels_max = HDA_STEREO,
 537                 .rates = SNDRV_PCM_RATE_48000,
 538                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 539         },
 540 },
 541 /* BE CPU  Dais */
 542 {
 543         .name = "SSP0 Pin",
 544         .ops = &skl_be_ssp_dai_ops,
 545         .playback = {
 546                 .stream_name = "ssp0 Tx",
 547                 .channels_min = HDA_STEREO,
 548                 .channels_max = HDA_STEREO,
 549                 .rates = SNDRV_PCM_RATE_48000,
 550                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 551         },
 552         .capture = {
 553                 .stream_name = "ssp0 Rx",
 554                 .channels_min = HDA_STEREO,
 555                 .channels_max = HDA_STEREO,
 556                 .rates = SNDRV_PCM_RATE_48000,
 557                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 558         },
 559 },
 560 {
 561         .name = "iDisp Pin",
 562         .ops = &skl_link_dai_ops,
 563         .playback = {
 564                 .stream_name = "iDisp Tx",
 565                 .channels_min = HDA_STEREO,
 566                 .channels_max = HDA_STEREO,
 567                 .rates = SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_48000,
 568                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 569         },
 570 },
 571 {
 572         .name = "DMIC01 Pin",
 573         .ops = &skl_dmic_dai_ops,
 574         .capture = {
 575                 .stream_name = "DMIC01 Rx",
 576                 .channels_min = HDA_STEREO,
 577                 .channels_max = HDA_STEREO,
 578                 .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_16000,
 579                 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
 580         },
 581 },
 582 {
 583         .name = "HD-Codec Pin",
 584         .ops = &skl_link_dai_ops,
 585         .playback = {
 586                 .stream_name = "HD-Codec Tx",
 587                 .channels_min = HDA_STEREO,
 588                 .channels_max = HDA_STEREO,
 589                 .rates = SNDRV_PCM_RATE_48000,
 590                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 591         },
 592         .capture = {
 593                 .stream_name = "HD-Codec Rx",
 594                 .channels_min = HDA_STEREO,
 595                 .channels_max = HDA_STEREO,
 596                 .rates = SNDRV_PCM_RATE_48000,
 597                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 598         },
 599 },
 600 };
 601
 602 static int skl_platform_open(struct snd_pcm_substream *substream)
 603 {
 604         struct snd_pcm_runtime *runtime;
 605         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 606         struct snd_soc_dai_link *dai_link = rtd->dai_link;
 607
 608         dev_dbg(rtd->cpu_dai->dev, "In %s:%s\n", __func__,
 609                                         dai_link->cpu_dai_name);
 610
 611         runtime = substream->runtime;
 612         snd_soc_set_runtime_hwparams(substream, &azx_pcm_hw);
 613
 614         return 0;
 615 }
 616
 617 static int skl_coupled_trigger(struct snd_pcm_substream *substream,
 618                                         int cmd)
 619 {
 620         struct hdac_ext_bus *ebus = get_bus_ctx(substream);
 621         struct hdac_bus *bus = ebus_to_hbus(ebus);
 622         struct hdac_ext_stream *stream;
 623         struct snd_pcm_substream *s;
 624         bool start;
 625         int sbits = 0;
 626         unsigned long cookie;
 627         struct hdac_stream *hstr;
 628
 629         stream = get_hdac_ext_stream(substream);
 630         hstr = hdac_stream(stream);
 631
 632         dev_dbg(bus->dev, "In %s cmd=%d\n", __func__, cmd);
 633
 634         if (!hstr->prepared)
 635                 return -EPIPE;
 636
 637         switch (cmd) {
 638         case SNDRV_PCM_TRIGGER_START:
 639         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 640         case SNDRV_PCM_TRIGGER_RESUME:
 641                 start = true;
 642                 break;
 643
 644         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 645         case SNDRV_PCM_TRIGGER_SUSPEND:
 646         case SNDRV_PCM_TRIGGER_STOP:
 647                 start = false;
 648                 break;
 649
 650         default:
 651                 return -EINVAL;
 652         }
 653
 654         snd_pcm_group_for_each_entry(s, substream) {
 655                 if (s->pcm->card != substream->pcm->card)
 656                         continue;
 657                 stream = get_hdac_ext_stream(s);
 658                 sbits |= 1 << hdac_stream(stream)->index;
 659                 snd_pcm_trigger_done(s, substream);
 660         }
 661
 662         spin_lock_irqsave(&bus->reg_lock, cookie);
 663
 664         /* first, set SYNC bits of corresponding streams */
 665         snd_hdac_stream_sync_trigger(hstr, true, sbits, AZX_REG_SSYNC);
 666
 667         snd_pcm_group_for_each_entry(s, substream) {
 668                 if (s->pcm->card != substream->pcm->card)
 669                         continue;
 670                 stream = get_hdac_ext_stream(s);
 671                 if (start)
 672                         snd_hdac_stream_start(hdac_stream(stream), true);
 673                 else
 674                         snd_hdac_stream_stop(hdac_stream(stream));
 675         }
 676         spin_unlock_irqrestore(&bus->reg_lock, cookie);
 677
 678         snd_hdac_stream_sync(hstr, start, sbits);
 679
 680         spin_lock_irqsave(&bus->reg_lock, cookie);
 681
 682         /* reset SYNC bits */
 683         snd_hdac_stream_sync_trigger(hstr, false, sbits, AZX_REG_SSYNC);
 684         if (start)
 685                 snd_hdac_stream_timecounter_init(hstr, sbits);
 686         spin_unlock_irqrestore(&bus->reg_lock, cookie);
 687
 688         return 0;
 689 }
 690
 691 static int skl_decoupled_trigger(struct snd_pcm_substream *substream,
 692                 int cmd)
 693 {
 694         struct hdac_ext_bus *ebus = get_bus_ctx(substream);
 695         struct hdac_bus *bus = ebus_to_hbus(ebus);
 696         struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 697         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 698         struct hdac_ext_stream *stream;
 699         int start;
 700         unsigned long cookie;
 701         struct hdac_stream *hstr;
 702
 703         dev_dbg(bus->dev, "In %s cmd=%d streamname=%s\n", __func__, cmd, cpu_dai->name);
 704
 705         stream = get_hdac_ext_stream(substream);
 706         hstr = hdac_stream(stream);
 707
 708         if (!hstr->prepared)
 709                 return -EPIPE;
 710
 711         switch (cmd) {
 712         case SNDRV_PCM_TRIGGER_START:
 713         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 714         case SNDRV_PCM_TRIGGER_RESUME:
 715                 start = 1;
 716                 break;
 717
 718         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 719         case SNDRV_PCM_TRIGGER_SUSPEND:
 720         case SNDRV_PCM_TRIGGER_STOP:
 721                 start = 0;
 722                 break;
 723
 724         default:
 725                 return -EINVAL;
 726         }
 727
 728         spin_lock_irqsave(&bus->reg_lock, cookie);
 729
 730         if (start)
 731                 snd_hdac_stream_start(hdac_stream(stream), true);
 732         else
 733                 snd_hdac_stream_stop(hdac_stream(stream));
 734
 735         if (start)
 736                 snd_hdac_stream_timecounter_init(hstr, 0);
 737
 738         spin_unlock_irqrestore(&bus->reg_lock, cookie);
 739
 740         return 0;
 741 }
 742 static int skl_platform_pcm_trigger(struct snd_pcm_substream *substream,
 743                                         int cmd)
 744 {
 745         struct hdac_ext_bus *ebus = get_bus_ctx(substream);
 746
 747         if (ebus->ppcap)
 748                 return skl_decoupled_trigger(substream, cmd);
 749         else
 750                 return skl_coupled_trigger(substream, cmd);
 751 }
 752
 753 /* calculate runtime delay from LPIB */
 754 static int skl_get_delay_from_lpib(struct hdac_ext_bus *ebus,
 755                                 struct hdac_ext_stream *sstream,
 756                                 unsigned int pos)
 757 {
 758         struct hdac_bus *bus = ebus_to_hbus(ebus);
 759         struct hdac_stream *hstream = hdac_stream(sstream);
 760         struct snd_pcm_substream *substream = hstream->substream;
 761         int stream = substream->stream;
 762         unsigned int lpib_pos = snd_hdac_stream_get_pos_lpib(hstream);
 763         int delay;
 764
 765         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
 766                 delay = pos - lpib_pos;
 767         else
 768                 delay = lpib_pos - pos;
 769
 770         if (delay < 0) {
 771                 if (delay >= hstream->delay_negative_threshold)
 772                         delay = 0;
 773                 else
 774                         delay += hstream->bufsize;
 775         }
 776
 777         if (delay >= hstream->period_bytes) {
 778                 dev_info(bus->dev,
 779                          "Unstable LPIB (%d >= %d); disabling LPIB delay counting\n",
 780                          delay, hstream->period_bytes);
 781                 delay = 0;
 782         }
 783
 784         return bytes_to_frames(substream->runtime, delay);
 785 }
 786
 787 static unsigned int skl_get_position(struct hdac_ext_stream *hstream,
 788                                         int codec_delay)
 789 {
 790         struct hdac_stream *hstr = hdac_stream(hstream);
 791         struct snd_pcm_substream *substream = hstr->substream;
 792         struct hdac_ext_bus *ebus = get_bus_ctx(substream);
 793         unsigned int pos;
 794         int delay;
 795
 796         /* use the position buffer as default */
 797         pos = snd_hdac_stream_get_pos_posbuf(hdac_stream(hstream));
 798
 799         if (pos >= hdac_stream(hstream)->bufsize)
 800                 pos = 0;
 801
 802         if (substream->runtime) {
 803                 delay = skl_get_delay_from_lpib(ebus, hstream, pos)
 804                                                  + codec_delay;
 805                 substream->runtime->delay += delay;
 806         }
 807
 808         return pos;
 809 }
 810
 811 static snd_pcm_uframes_t skl_platform_pcm_pointer
 812                         (struct snd_pcm_substream *substream)
 813 {
 814         struct hdac_ext_stream *hstream = get_hdac_ext_stream(substream);
 815
 816         return bytes_to_frames(substream->runtime,
 817                                skl_get_position(hstream, 0));
 818 }
 819
 820 static u64 skl_adjust_codec_delay(struct snd_pcm_substream *substream,
 821                                 u64 nsec)
 822 {
 823         struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
 824         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 825         u64 codec_frames, codec_nsecs;
 826
 827         if (!codec_dai->driver->ops->delay)
 828                 return nsec;
 829
 830         codec_frames = codec_dai->driver->ops->delay(substream, codec_dai);
 831         codec_nsecs = div_u64(codec_frames * 1000000000LL,
 832                               substream->runtime->rate);
 833
 834         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 835                 return nsec + codec_nsecs;
 836
 837         return (nsec > codec_nsecs) ? nsec - codec_nsecs : 0;
 838 }
 839
 840 static int skl_get_time_info(struct snd_pcm_substream *substream,
 841                         struct timespec *system_ts, struct timespec *audio_ts,
 842                         struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
 843                         struct snd_pcm_audio_tstamp_report *audio_tstamp_report)
 844 {
 845         struct hdac_ext_stream *sstream = get_hdac_ext_stream(substream);
 846         struct hdac_stream *hstr = hdac_stream(sstream);
 847         u64 nsec;
 848
 849         if ((substream->runtime->hw.info & SNDRV_PCM_INFO_HAS_LINK_ATIME) &&
 850                 (audio_tstamp_config->type_requested == SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK)) {
 851
 852                 snd_pcm_gettime(substream->runtime, system_ts);
 853
 854                 nsec = timecounter_read(&hstr->tc);
 855                 nsec = div_u64(nsec, 3); /* can be optimized */
 856                 if (audio_tstamp_config->report_delay)
 857                         nsec = skl_adjust_codec_delay(substream, nsec);
 858
 859                 *audio_ts = ns_to_timespec(nsec);
 860
 861                 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK;
 862                 audio_tstamp_report->accuracy_report = 1; /* rest of struct is valid */
 863                 audio_tstamp_report->accuracy = 42; /* 24MHzWallClk == 42ns resolution */
 864
 865         } else {
 866                 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT;
 867         }
 868
 869         return 0;
 870 }
 871
 872 static struct snd_pcm_ops skl_platform_ops = {
 873         .open = skl_platform_open,
 874         .ioctl = snd_pcm_lib_ioctl,
 875         .trigger = skl_platform_pcm_trigger,
 876         .pointer = skl_platform_pcm_pointer,
 877         .get_time_info =  skl_get_time_info,
 878         .mmap = snd_pcm_lib_default_mmap,
 879         .page = snd_pcm_sgbuf_ops_page,
 880 };
 881
 882 static void skl_pcm_free(struct snd_pcm *pcm)
 883 {
 884         snd_pcm_lib_preallocate_free_for_all(pcm);
 885 }
 886
 887 #define MAX_PREALLOC_SIZE       (32 * 1024 * 1024)
 888
 889 static int skl_pcm_new(struct snd_soc_pcm_runtime *rtd)
 890 {
 891         struct snd_soc_dai *dai = rtd->cpu_dai;
 892         struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev);
 893         struct snd_pcm *pcm = rtd->pcm;
 894         unsigned int size;
 895         int retval = 0;
 896         struct skl *skl = ebus_to_skl(ebus);
 897
 898         if (dai->driver->playback.channels_min ||
 899                 dai->driver->capture.channels_min) {
 900                 /* buffer pre-allocation */
 901                 size = CONFIG_SND_HDA_PREALLOC_SIZE * 1024;
 902                 if (size > MAX_PREALLOC_SIZE)
 903                         size = MAX_PREALLOC_SIZE;
 904                 retval = snd_pcm_lib_preallocate_pages_for_all(pcm,
 905                                                 SNDRV_DMA_TYPE_DEV_SG,
 906                                                 snd_dma_pci_data(skl->pci),
 907                                                 size, MAX_PREALLOC_SIZE);
 908                 if (retval) {
 909                         dev_err(dai->dev, "dma buffer allocationf fail\n");
 910                         return retval;
 911                 }
 912         }
 913
 914         return retval;
 915 }
 916
 917 static int skl_platform_soc_probe(struct snd_soc_platform *platform)
 918 {
 919         struct hdac_ext_bus *ebus = dev_get_drvdata(platform->dev);
 920
 921         if (ebus->ppcap)
 922                 return skl_tplg_init(platform, ebus);
 923
 924         return 0;
 925 }
 926 static struct snd_soc_platform_driver skl_platform_drv  = {
 927         .probe          = skl_platform_soc_probe,
 928         .ops            = &skl_platform_ops,
 929         .pcm_new        = skl_pcm_new,
 930         .pcm_free       = skl_pcm_free,
 931 };
 932
 933 static const struct snd_soc_component_driver skl_component = {
 934         .name           = "pcm",
 935 };
 936
 937 int skl_platform_register(struct device *dev)
 938 {
 939         int ret;
 940         struct hdac_ext_bus *ebus = dev_get_drvdata(dev);
 941         struct skl *skl = ebus_to_skl(ebus);
 942
 943         INIT_LIST_HEAD(&skl->ppl_list);
 944         INIT_LIST_HEAD(&skl->dapm_path_list);
 945
 946         ret = snd_soc_register_platform(dev, &skl_platform_drv);
 947         if (ret) {
 948                 dev_err(dev, "soc platform registration failed %d\n", ret);
 949                 return ret;
 950         }
 951         ret = snd_soc_register_component(dev, &skl_component,
 952                                 skl_platform_dai,
 953                                 ARRAY_SIZE(skl_platform_dai));
 954         if (ret) {
 955                 dev_err(dev, "soc component registration failed %d\n", ret);
 956                 snd_soc_unregister_platform(dev);
 957         }
 958
 959         return ret;
 960
 961 }
 962
 963 int skl_platform_unregister(struct device *dev)
 964 {
 965         snd_soc_unregister_component(dev);
 966         snd_soc_unregister_platform(dev);
 967         return 0;
 968 }