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