projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branches 'asoc/topic/rt298', 'asoc/topic/rt5640', 'asoc/topic...
[deliverable/linux.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
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 }
Linux kernel - Deliverables
This page took 0.058328 seconds and 5 git commands to generate.