projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'pm+acpi-4.4-rc1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[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 #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 }
Linux kernel - Deliverables
This page took 0.076752 seconds and 6 git commands to generate.