GNU Linux-libre 4.4.290-gnu1
[releases.git] / 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 }