1 // SPDX-License-Identifier: GPL-2.0-only
3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
6 // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
9 #include <linux/debugfs.h>
10 #include <linux/device.h>
11 #include <sound/hda_register.h>
12 #include <sound/hdaudio_ext.h>
13 #include <sound/pcm_params.h>
14 #include <sound/soc-acpi.h>
15 #include <sound/soc-acpi-intel-match.h>
16 #include <sound/soc-component.h>
22 struct avs_tplg_path_template *template;
23 struct avs_path *path;
25 * link stream is stored within substream's runtime
26 * private_data to fulfill the needs of codec BE path
28 * host stream assigned
30 struct hdac_ext_stream *host_stream;
32 struct snd_pcm_substream *substream;
35 static struct avs_tplg_path_template *
36 avs_dai_find_path_template(struct snd_soc_dai *dai, bool is_fe, int direction)
38 struct snd_soc_dapm_widget *dw = snd_soc_dai_get_widget(dai, direction);
39 struct snd_soc_dapm_path *dp;
40 enum snd_soc_dapm_direction dir;
42 if (direction == SNDRV_PCM_STREAM_CAPTURE) {
43 dir = is_fe ? SND_SOC_DAPM_DIR_OUT : SND_SOC_DAPM_DIR_IN;
45 dir = is_fe ? SND_SOC_DAPM_DIR_IN : SND_SOC_DAPM_DIR_OUT;
48 dp = list_first_entry_or_null(&dw->edges[dir], typeof(*dp), list_node[dir]);
52 /* Get the other widget, with actual path template data */
53 dw = (dp->source == dw) ? dp->sink : dp->source;
58 static int avs_dai_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai, bool is_fe,
59 const struct snd_soc_dai_ops *ops)
61 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
62 struct avs_dev *adev = to_avs_dev(dai->dev);
63 struct avs_tplg_path_template *template;
64 struct avs_dma_data *data;
66 template = avs_dai_find_path_template(dai, is_fe, substream->stream);
68 dev_err(dai->dev, "no %s path for dai %s, invalid tplg?\n",
69 snd_pcm_stream_str(substream), dai->name);
73 data = kzalloc(sizeof(*data), GFP_KERNEL);
77 data->substream = substream;
78 data->template = template;
79 snd_soc_dai_set_dma_data(dai, substream, data);
81 if (rtd->dai_link->ignore_suspend)
87 static int avs_dai_hw_params(struct snd_pcm_substream *substream,
88 struct snd_pcm_hw_params *fe_hw_params,
89 struct snd_pcm_hw_params *be_hw_params, struct snd_soc_dai *dai,
92 struct avs_dma_data *data;
93 struct avs_path *path;
94 struct avs_dev *adev = to_avs_dev(dai->dev);
97 data = snd_soc_dai_get_dma_data(dai, substream);
99 dev_dbg(dai->dev, "%s FE hw_params str %p rtd %p",
100 __func__, substream, substream->runtime);
101 dev_dbg(dai->dev, "rate %d chn %d vbd %d bd %d\n",
102 params_rate(fe_hw_params), params_channels(fe_hw_params),
103 params_width(fe_hw_params), params_physical_width(fe_hw_params));
105 dev_dbg(dai->dev, "%s BE hw_params str %p rtd %p",
106 __func__, substream, substream->runtime);
107 dev_dbg(dai->dev, "rate %d chn %d vbd %d bd %d\n",
108 params_rate(be_hw_params), params_channels(be_hw_params),
109 params_width(be_hw_params), params_physical_width(be_hw_params));
111 path = avs_path_create(adev, dma_id, data->template, fe_hw_params, be_hw_params);
114 dev_err(dai->dev, "create path failed: %d\n", ret);
122 static int avs_dai_be_hw_params(struct snd_pcm_substream *substream,
123 struct snd_pcm_hw_params *be_hw_params, struct snd_soc_dai *dai,
126 struct snd_pcm_hw_params *fe_hw_params = NULL;
127 struct snd_soc_pcm_runtime *fe, *be;
128 struct snd_soc_dpcm *dpcm;
130 be = snd_soc_substream_to_rtd(substream);
131 for_each_dpcm_fe(be, substream->stream, dpcm) {
133 fe_hw_params = &fe->dpcm[substream->stream].hw_params;
136 return avs_dai_hw_params(substream, fe_hw_params, be_hw_params, dai, dma_id);
139 static int avs_dai_prepare(struct avs_dev *adev, struct snd_pcm_substream *substream,
140 struct snd_soc_dai *dai)
142 struct avs_dma_data *data;
145 data = snd_soc_dai_get_dma_data(dai, substream);
149 ret = avs_path_reset(data->path);
151 dev_err(dai->dev, "reset path failed: %d\n", ret);
155 ret = avs_path_pause(data->path);
157 dev_err(dai->dev, "pause path failed: %d\n", ret);
161 static const struct snd_soc_dai_ops avs_dai_nonhda_be_ops;
163 static int avs_dai_nonhda_be_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
165 return avs_dai_startup(substream, dai, false, &avs_dai_nonhda_be_ops);
168 static void avs_dai_nonhda_be_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
170 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
171 struct avs_dev *adev = to_avs_dev(dai->dev);
172 struct avs_dma_data *data;
174 if (rtd->dai_link->ignore_suspend)
175 adev->num_lp_paths--;
177 data = snd_soc_dai_get_dma_data(dai, substream);
179 snd_soc_dai_set_dma_data(dai, substream, NULL);
183 static int avs_dai_nonhda_be_hw_params(struct snd_pcm_substream *substream,
184 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai)
186 struct avs_dma_data *data;
188 data = snd_soc_dai_get_dma_data(dai, substream);
192 /* Actual port-id comes from topology. */
193 return avs_dai_be_hw_params(substream, hw_params, dai, 0);
196 static int avs_dai_nonhda_be_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
198 struct avs_dma_data *data;
200 dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
202 data = snd_soc_dai_get_dma_data(dai, substream);
204 avs_path_free(data->path);
211 static int avs_dai_nonhda_be_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
213 return avs_dai_prepare(to_avs_dev(dai->dev), substream, dai);
216 static int avs_dai_nonhda_be_trigger(struct snd_pcm_substream *substream, int cmd,
217 struct snd_soc_dai *dai)
219 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
220 struct avs_dma_data *data;
223 data = snd_soc_dai_get_dma_data(dai, substream);
226 case SNDRV_PCM_TRIGGER_RESUME:
227 if (rtd->dai_link->ignore_suspend)
230 case SNDRV_PCM_TRIGGER_START:
231 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
232 ret = avs_path_pause(data->path);
234 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
238 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO);
240 dev_err(dai->dev, "run BE path failed: %d\n", ret);
243 case SNDRV_PCM_TRIGGER_SUSPEND:
244 if (rtd->dai_link->ignore_suspend)
247 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
248 case SNDRV_PCM_TRIGGER_STOP:
249 ret = avs_path_pause(data->path);
251 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
253 ret = avs_path_reset(data->path);
255 dev_err(dai->dev, "reset BE path failed: %d\n", ret);
266 static const struct snd_soc_dai_ops avs_dai_nonhda_be_ops = {
267 .startup = avs_dai_nonhda_be_startup,
268 .shutdown = avs_dai_nonhda_be_shutdown,
269 .hw_params = avs_dai_nonhda_be_hw_params,
270 .hw_free = avs_dai_nonhda_be_hw_free,
271 .prepare = avs_dai_nonhda_be_prepare,
272 .trigger = avs_dai_nonhda_be_trigger,
275 static const struct snd_soc_dai_ops avs_dai_hda_be_ops;
277 static int avs_dai_hda_be_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
279 return avs_dai_startup(substream, dai, false, &avs_dai_hda_be_ops);
282 static void avs_dai_hda_be_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
284 return avs_dai_nonhda_be_shutdown(substream, dai);
287 static int avs_dai_hda_be_hw_params(struct snd_pcm_substream *substream,
288 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai)
290 struct avs_dma_data *data;
291 struct hdac_ext_stream *link_stream;
293 data = snd_soc_dai_get_dma_data(dai, substream);
297 link_stream = substream->runtime->private_data;
299 return avs_dai_be_hw_params(substream, hw_params, dai,
300 hdac_stream(link_stream)->stream_tag - 1);
303 static int avs_dai_hda_be_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
305 struct avs_dma_data *data;
306 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
307 struct hdac_ext_stream *link_stream;
308 struct hdac_ext_link *link;
309 struct hda_codec *codec;
311 dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
313 data = snd_soc_dai_get_dma_data(dai, substream);
317 link_stream = substream->runtime->private_data;
318 link_stream->link_prepared = false;
319 avs_path_free(data->path);
322 /* clear link <-> stream mapping */
323 codec = dev_to_hda_codec(snd_soc_rtd_to_codec(rtd, 0)->dev);
324 link = snd_hdac_ext_bus_get_hlink_by_addr(&codec->bus->core, codec->core.addr);
328 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
329 snd_hdac_ext_bus_link_clear_stream_id(link, hdac_stream(link_stream)->stream_tag);
334 static int avs_dai_hda_be_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
336 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
337 struct snd_pcm_runtime *runtime = substream->runtime;
338 struct hdac_ext_stream *link_stream = runtime->private_data;
339 struct hdac_ext_link *link;
340 struct hda_codec *codec;
341 struct hdac_bus *bus;
342 unsigned int format_val;
345 if (link_stream->link_prepared)
348 codec = dev_to_hda_codec(snd_soc_rtd_to_codec(rtd, 0)->dev);
349 bus = &codec->bus->core;
350 format_val = snd_hdac_calc_stream_format(runtime->rate, runtime->channels, runtime->format,
351 runtime->sample_bits, 0);
353 snd_hdac_ext_stream_reset(link_stream);
354 snd_hdac_ext_stream_setup(link_stream, format_val);
356 link = snd_hdac_ext_bus_get_hlink_by_addr(bus, codec->core.addr);
360 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
361 snd_hdac_ext_bus_link_set_stream_id(link, hdac_stream(link_stream)->stream_tag);
363 ret = avs_dai_prepare(to_avs_dev(dai->dev), substream, dai);
367 link_stream->link_prepared = true;
371 static int avs_dai_hda_be_trigger(struct snd_pcm_substream *substream, int cmd,
372 struct snd_soc_dai *dai)
374 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
375 struct hdac_ext_stream *link_stream;
376 struct avs_dma_data *data;
379 dev_dbg(dai->dev, "entry %s cmd=%d\n", __func__, cmd);
381 data = snd_soc_dai_get_dma_data(dai, substream);
382 link_stream = substream->runtime->private_data;
385 case SNDRV_PCM_TRIGGER_RESUME:
386 if (rtd->dai_link->ignore_suspend)
389 case SNDRV_PCM_TRIGGER_START:
390 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
391 snd_hdac_ext_stream_start(link_stream);
393 ret = avs_path_pause(data->path);
395 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
399 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO);
401 dev_err(dai->dev, "run BE path failed: %d\n", ret);
404 case SNDRV_PCM_TRIGGER_SUSPEND:
405 if (rtd->dai_link->ignore_suspend)
408 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
409 case SNDRV_PCM_TRIGGER_STOP:
410 ret = avs_path_pause(data->path);
412 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
414 snd_hdac_ext_stream_clear(link_stream);
416 ret = avs_path_reset(data->path);
418 dev_err(dai->dev, "reset BE path failed: %d\n", ret);
429 static const struct snd_soc_dai_ops avs_dai_hda_be_ops = {
430 .startup = avs_dai_hda_be_startup,
431 .shutdown = avs_dai_hda_be_shutdown,
432 .hw_params = avs_dai_hda_be_hw_params,
433 .hw_free = avs_dai_hda_be_hw_free,
434 .prepare = avs_dai_hda_be_prepare,
435 .trigger = avs_dai_hda_be_trigger,
438 static const unsigned int rates[] = {
439 8000, 11025, 12000, 16000,
440 22050, 24000, 32000, 44100,
441 48000, 64000, 88200, 96000,
442 128000, 176400, 192000,
445 static const struct snd_pcm_hw_constraint_list hw_rates = {
446 .count = ARRAY_SIZE(rates),
451 const struct snd_soc_dai_ops avs_dai_fe_ops;
453 static int avs_dai_fe_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
455 struct snd_pcm_runtime *runtime = substream->runtime;
456 struct avs_dma_data *data;
457 struct avs_dev *adev = to_avs_dev(dai->dev);
458 struct hdac_bus *bus = &adev->base.core;
459 struct hdac_ext_stream *host_stream;
462 ret = avs_dai_startup(substream, dai, true, &avs_dai_fe_ops);
466 data = snd_soc_dai_get_dma_data(dai, substream);
468 host_stream = snd_hdac_ext_stream_assign(bus, substream, HDAC_EXT_STREAM_TYPE_HOST);
474 data->host_stream = host_stream;
475 ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
479 /* avoid wrap-around with wall-clock */
480 ret = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 20, 178000000);
484 ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_rates);
488 snd_pcm_set_sync(substream);
490 dev_dbg(dai->dev, "%s fe STARTUP tag %d str %p",
491 __func__, hdac_stream(host_stream)->stream_tag, substream);
500 static void avs_dai_fe_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
502 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
503 struct avs_dev *adev = to_avs_dev(dai->dev);
504 struct avs_dma_data *data;
506 if (rtd->dai_link->ignore_suspend)
507 adev->num_lp_paths--;
509 data = snd_soc_dai_get_dma_data(dai, substream);
511 snd_soc_dai_set_dma_data(dai, substream, NULL);
512 snd_hdac_ext_stream_release(data->host_stream, HDAC_EXT_STREAM_TYPE_HOST);
516 static int avs_dai_fe_hw_params(struct snd_pcm_substream *substream,
517 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai)
519 struct snd_pcm_hw_params *be_hw_params = NULL;
520 struct snd_soc_pcm_runtime *fe, *be;
521 struct snd_soc_dpcm *dpcm;
522 struct avs_dma_data *data;
523 struct hdac_ext_stream *host_stream;
526 data = snd_soc_dai_get_dma_data(dai, substream);
530 host_stream = data->host_stream;
532 hdac_stream(host_stream)->bufsize = 0;
533 hdac_stream(host_stream)->period_bytes = 0;
534 hdac_stream(host_stream)->format_val = 0;
536 fe = snd_soc_substream_to_rtd(substream);
537 for_each_dpcm_be(fe, substream->stream, dpcm) {
539 be_hw_params = &be->dpcm[substream->stream].hw_params;
542 ret = avs_dai_hw_params(substream, hw_params, be_hw_params, dai,
543 hdac_stream(host_stream)->stream_tag - 1);
547 ret = avs_path_bind(data->path);
549 dev_err(dai->dev, "bind FE <-> BE failed: %d\n", ret);
556 avs_path_free(data->path);
559 snd_pcm_lib_free_pages(substream);
563 static int __avs_dai_fe_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
565 struct avs_dma_data *data;
566 struct hdac_ext_stream *host_stream;
569 dev_dbg(dai->dev, "%s fe HW_FREE str %p rtd %p",
570 __func__, substream, substream->runtime);
572 data = snd_soc_dai_get_dma_data(dai, substream);
576 host_stream = data->host_stream;
578 ret = avs_path_unbind(data->path);
580 dev_err(dai->dev, "unbind FE <-> BE failed: %d\n", ret);
582 avs_path_free(data->path);
584 snd_hdac_stream_cleanup(hdac_stream(host_stream));
585 hdac_stream(host_stream)->prepared = false;
590 static int avs_dai_fe_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
594 ret = __avs_dai_fe_hw_free(substream, dai);
595 snd_pcm_lib_free_pages(substream);
600 static int avs_dai_fe_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
602 struct snd_pcm_runtime *runtime = substream->runtime;
603 struct avs_dma_data *data;
604 struct avs_dev *adev = to_avs_dev(dai->dev);
605 struct hdac_ext_stream *host_stream;
606 unsigned int format_val;
609 data = snd_soc_dai_get_dma_data(dai, substream);
610 host_stream = data->host_stream;
612 if (hdac_stream(host_stream)->prepared)
615 snd_hdac_stream_reset(hdac_stream(host_stream));
617 format_val = snd_hdac_calc_stream_format(runtime->rate, runtime->channels, runtime->format,
618 runtime->sample_bits, 0);
620 ret = snd_hdac_stream_set_params(hdac_stream(host_stream), format_val);
624 ret = snd_hdac_ext_host_stream_setup(host_stream, false);
628 ret = avs_dai_prepare(adev, substream, dai);
632 hdac_stream(host_stream)->prepared = true;
636 static int avs_dai_fe_trigger(struct snd_pcm_substream *substream, int cmd, struct snd_soc_dai *dai)
638 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
639 struct avs_dma_data *data;
640 struct hdac_ext_stream *host_stream;
641 struct hdac_bus *bus;
645 data = snd_soc_dai_get_dma_data(dai, substream);
646 host_stream = data->host_stream;
647 bus = hdac_stream(host_stream)->bus;
650 case SNDRV_PCM_TRIGGER_RESUME:
651 if (rtd->dai_link->ignore_suspend)
654 case SNDRV_PCM_TRIGGER_START:
655 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
656 spin_lock_irqsave(&bus->reg_lock, flags);
657 snd_hdac_stream_start(hdac_stream(host_stream));
658 spin_unlock_irqrestore(&bus->reg_lock, flags);
660 /* Timeout on DRSM poll shall not stop the resume so ignore the result. */
661 if (cmd == SNDRV_PCM_TRIGGER_RESUME)
662 snd_hdac_stream_wait_drsm(hdac_stream(host_stream));
664 ret = avs_path_pause(data->path);
666 dev_err(dai->dev, "pause FE path failed: %d\n", ret);
670 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO);
672 dev_err(dai->dev, "run FE path failed: %d\n", ret);
676 case SNDRV_PCM_TRIGGER_SUSPEND:
677 if (rtd->dai_link->ignore_suspend)
680 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
681 case SNDRV_PCM_TRIGGER_STOP:
682 ret = avs_path_pause(data->path);
684 dev_err(dai->dev, "pause FE path failed: %d\n", ret);
686 spin_lock_irqsave(&bus->reg_lock, flags);
687 snd_hdac_stream_stop(hdac_stream(host_stream));
688 spin_unlock_irqrestore(&bus->reg_lock, flags);
690 ret = avs_path_reset(data->path);
692 dev_err(dai->dev, "reset FE path failed: %d\n", ret);
703 const struct snd_soc_dai_ops avs_dai_fe_ops = {
704 .startup = avs_dai_fe_startup,
705 .shutdown = avs_dai_fe_shutdown,
706 .hw_params = avs_dai_fe_hw_params,
707 .hw_free = avs_dai_fe_hw_free,
708 .prepare = avs_dai_fe_prepare,
709 .trigger = avs_dai_fe_trigger,
712 static ssize_t topology_name_read(struct file *file, char __user *user_buf, size_t count,
715 struct snd_soc_component *component = file->private_data;
716 struct snd_soc_card *card = component->card;
717 struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev);
721 len = scnprintf(buf, sizeof(buf), "%s/%s\n", component->driver->topology_name_prefix,
722 mach->tplg_filename);
724 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
727 static const struct file_operations topology_name_fops = {
729 .read = topology_name_read,
730 .llseek = default_llseek,
733 static int avs_component_load_libraries(struct avs_soc_component *acomp)
735 struct avs_tplg *tplg = acomp->tplg;
736 struct avs_dev *adev = to_avs_dev(acomp->base.dev);
742 /* Parent device may be asleep and library loading involves IPCs. */
743 ret = pm_runtime_resume_and_get(adev->dev);
747 avs_hda_power_gating_enable(adev, false);
748 avs_hda_clock_gating_enable(adev, false);
749 avs_hda_l1sen_enable(adev, false);
751 ret = avs_dsp_load_libraries(adev, tplg->libs, tplg->num_libs);
753 avs_hda_l1sen_enable(adev, true);
754 avs_hda_clock_gating_enable(adev, true);
755 avs_hda_power_gating_enable(adev, true);
758 ret = avs_module_info_init(adev, false);
760 pm_runtime_mark_last_busy(adev->dev);
761 pm_runtime_put_autosuspend(adev->dev);
766 static int avs_component_probe(struct snd_soc_component *component)
768 struct snd_soc_card *card = component->card;
769 struct snd_soc_acpi_mach *mach;
770 struct avs_soc_component *acomp;
771 struct avs_dev *adev;
775 dev_dbg(card->dev, "probing %s card %s\n", component->name, card->name);
776 mach = dev_get_platdata(card->dev);
777 acomp = to_avs_soc_component(component);
778 adev = to_avs_dev(component->dev);
780 acomp->tplg = avs_tplg_new(component);
784 if (!mach->tplg_filename)
787 /* Load specified topology and create debugfs for it. */
788 filename = kasprintf(GFP_KERNEL, "%s/%s", component->driver->topology_name_prefix,
789 mach->tplg_filename);
793 ret = avs_load_topology(component, filename);
795 if (ret == -ENOENT && !strncmp(mach->tplg_filename, "hda-", 4)) {
796 unsigned int vendor_id;
798 if (sscanf(mach->tplg_filename, "/*(DEBLOBBED)*/", &vendor_id) != 1)
801 if (((vendor_id >> 16) & 0xFFFF) == 0x8086)
802 mach->tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL,
805 mach->tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL,
808 filename = kasprintf(GFP_KERNEL, "%s/%s", component->driver->topology_name_prefix,
809 mach->tplg_filename);
813 dev_info(card->dev, "trying to load fallback topology %s\n", mach->tplg_filename);
814 ret = avs_load_topology(component, filename);
820 ret = avs_component_load_libraries(acomp);
822 dev_err(card->dev, "libraries loading failed: %d\n", ret);
827 debugfs_create_file("topology_name", 0444, component->debugfs_root, component,
828 &topology_name_fops);
830 mutex_lock(&adev->comp_list_mutex);
831 list_add_tail(&acomp->node, &adev->comp_list);
832 mutex_unlock(&adev->comp_list_mutex);
837 avs_remove_topology(component);
841 static void avs_component_remove(struct snd_soc_component *component)
843 struct avs_soc_component *acomp = to_avs_soc_component(component);
844 struct snd_soc_acpi_mach *mach;
845 struct avs_dev *adev = to_avs_dev(component->dev);
848 mach = dev_get_platdata(component->card->dev);
850 mutex_lock(&adev->comp_list_mutex);
851 list_del(&acomp->node);
852 mutex_unlock(&adev->comp_list_mutex);
854 if (mach->tplg_filename) {
855 ret = avs_remove_topology(component);
857 dev_err(component->dev, "unload topology failed: %d\n", ret);
861 static int avs_dai_resume_hw_params(struct snd_soc_dai *dai, struct avs_dma_data *data)
863 struct snd_pcm_substream *substream;
864 struct snd_soc_pcm_runtime *rtd;
867 substream = data->substream;
868 rtd = snd_soc_substream_to_rtd(substream);
870 ret = dai->driver->ops->hw_params(substream, &rtd->dpcm[substream->stream].hw_params, dai);
872 dev_err(dai->dev, "hw_params on resume failed: %d\n", ret);
877 static int avs_dai_resume_fe_prepare(struct snd_soc_dai *dai, struct avs_dma_data *data)
879 struct hdac_ext_stream *host_stream;
880 struct hdac_stream *hstream;
881 struct hdac_bus *bus;
884 host_stream = data->host_stream;
885 hstream = hdac_stream(host_stream);
886 bus = hdac_stream(host_stream)->bus;
888 /* Set DRSM before programming stream and position registers. */
889 snd_hdac_stream_drsm_enable(bus, true, hstream->index);
891 ret = dai->driver->ops->prepare(data->substream, dai);
893 dev_err(dai->dev, "prepare FE on resume failed: %d\n", ret);
897 writel(host_stream->pphcllpl, host_stream->pphc_addr + AZX_REG_PPHCLLPL);
898 writel(host_stream->pphcllpu, host_stream->pphc_addr + AZX_REG_PPHCLLPU);
899 writel(host_stream->pphcldpl, host_stream->pphc_addr + AZX_REG_PPHCLDPL);
900 writel(host_stream->pphcldpu, host_stream->pphc_addr + AZX_REG_PPHCLDPU);
902 /* As per HW spec recommendation, program LPIB and DPIB to the same value. */
903 snd_hdac_stream_set_lpib(hstream, hstream->lpib);
904 snd_hdac_stream_set_dpibr(bus, hstream, hstream->lpib);
909 static int avs_dai_resume_be_prepare(struct snd_soc_dai *dai, struct avs_dma_data *data)
913 ret = dai->driver->ops->prepare(data->substream, dai);
915 dev_err(dai->dev, "prepare BE on resume failed: %d\n", ret);
920 static int avs_dai_suspend_fe_hw_free(struct snd_soc_dai *dai, struct avs_dma_data *data)
922 struct hdac_ext_stream *host_stream;
925 host_stream = data->host_stream;
927 /* Store position addresses so we can resume from them later on. */
928 hdac_stream(host_stream)->lpib = snd_hdac_stream_get_pos_lpib(hdac_stream(host_stream));
929 host_stream->pphcllpl = readl(host_stream->pphc_addr + AZX_REG_PPHCLLPL);
930 host_stream->pphcllpu = readl(host_stream->pphc_addr + AZX_REG_PPHCLLPU);
931 host_stream->pphcldpl = readl(host_stream->pphc_addr + AZX_REG_PPHCLDPL);
932 host_stream->pphcldpu = readl(host_stream->pphc_addr + AZX_REG_PPHCLDPU);
934 ret = __avs_dai_fe_hw_free(data->substream, dai);
936 dev_err(dai->dev, "hw_free FE on suspend failed: %d\n", ret);
941 static int avs_dai_suspend_be_hw_free(struct snd_soc_dai *dai, struct avs_dma_data *data)
945 ret = dai->driver->ops->hw_free(data->substream, dai);
947 dev_err(dai->dev, "hw_free BE on suspend failed: %d\n", ret);
952 static int avs_component_pm_op(struct snd_soc_component *component, bool be,
953 int (*op)(struct snd_soc_dai *, struct avs_dma_data *))
955 struct snd_soc_pcm_runtime *rtd;
956 struct avs_dma_data *data;
957 struct snd_soc_dai *dai;
960 for_each_component_dais(component, dai) {
961 data = snd_soc_dai_dma_data_get_playback(dai);
963 rtd = snd_soc_substream_to_rtd(data->substream);
964 if (rtd->dai_link->no_pcm == be && !rtd->dai_link->ignore_suspend) {
967 __snd_pcm_set_state(data->substream->runtime,
968 SNDRV_PCM_STATE_DISCONNECTED);
974 data = snd_soc_dai_dma_data_get_capture(dai);
976 rtd = snd_soc_substream_to_rtd(data->substream);
977 if (rtd->dai_link->no_pcm == be && !rtd->dai_link->ignore_suspend) {
980 __snd_pcm_set_state(data->substream->runtime,
981 SNDRV_PCM_STATE_DISCONNECTED);
991 static int avs_component_resume_hw_params(struct snd_soc_component *component, bool be)
993 return avs_component_pm_op(component, be, &avs_dai_resume_hw_params);
996 static int avs_component_resume_prepare(struct snd_soc_component *component, bool be)
998 int (*prepare_cb)(struct snd_soc_dai *dai, struct avs_dma_data *data);
1001 prepare_cb = &avs_dai_resume_be_prepare;
1003 prepare_cb = &avs_dai_resume_fe_prepare;
1005 return avs_component_pm_op(component, be, prepare_cb);
1008 static int avs_component_suspend_hw_free(struct snd_soc_component *component, bool be)
1010 int (*hw_free_cb)(struct snd_soc_dai *dai, struct avs_dma_data *data);
1013 hw_free_cb = &avs_dai_suspend_be_hw_free;
1015 hw_free_cb = &avs_dai_suspend_fe_hw_free;
1017 return avs_component_pm_op(component, be, hw_free_cb);
1020 static int avs_component_suspend(struct snd_soc_component *component)
1025 * When freeing paths, FEs need to be first as they perform
1028 ret = avs_component_suspend_hw_free(component, false);
1032 return avs_component_suspend_hw_free(component, true);
1035 static int avs_component_resume(struct snd_soc_component *component)
1040 * When creating paths, FEs need to be last as they perform
1043 ret = avs_component_resume_hw_params(component, true);
1047 ret = avs_component_resume_hw_params(component, false);
1051 /* It is expected that the LINK stream is prepared first. */
1052 ret = avs_component_resume_prepare(component, true);
1056 return avs_component_resume_prepare(component, false);
1059 static const struct snd_pcm_hardware avs_pcm_hardware = {
1060 .info = SNDRV_PCM_INFO_MMAP |
1061 SNDRV_PCM_INFO_MMAP_VALID |
1062 SNDRV_PCM_INFO_INTERLEAVED |
1063 SNDRV_PCM_INFO_PAUSE |
1064 SNDRV_PCM_INFO_RESUME |
1065 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
1066 .formats = SNDRV_PCM_FMTBIT_S16_LE |
1067 SNDRV_PCM_FMTBIT_S24_LE |
1068 SNDRV_PCM_FMTBIT_S32_LE,
1069 .buffer_bytes_max = AZX_MAX_BUF_SIZE,
1070 .period_bytes_min = 128,
1071 .period_bytes_max = AZX_MAX_BUF_SIZE / 2,
1073 .periods_max = AZX_MAX_FRAG,
1077 static int avs_component_open(struct snd_soc_component *component,
1078 struct snd_pcm_substream *substream)
1080 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1082 /* only FE DAI links are handled here */
1083 if (rtd->dai_link->no_pcm)
1086 return snd_soc_set_runtime_hwparams(substream, &avs_pcm_hardware);
1089 static unsigned int avs_hda_stream_dpib_read(struct hdac_ext_stream *stream)
1091 return readl(hdac_stream(stream)->bus->remap_addr + AZX_REG_VS_SDXDPIB_XBASE +
1092 (AZX_REG_VS_SDXDPIB_XINTERVAL * hdac_stream(stream)->index));
1095 static snd_pcm_uframes_t
1096 avs_component_pointer(struct snd_soc_component *component, struct snd_pcm_substream *substream)
1098 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1099 struct avs_dma_data *data;
1100 struct hdac_ext_stream *host_stream;
1103 data = snd_soc_dai_get_dma_data(snd_soc_rtd_to_cpu(rtd, 0), substream);
1104 if (!data->host_stream)
1107 host_stream = data->host_stream;
1108 pos = avs_hda_stream_dpib_read(host_stream);
1110 if (pos >= hdac_stream(host_stream)->bufsize)
1113 return bytes_to_frames(substream->runtime, pos);
1116 static int avs_component_mmap(struct snd_soc_component *component,
1117 struct snd_pcm_substream *substream,
1118 struct vm_area_struct *vma)
1120 return snd_pcm_lib_default_mmap(substream, vma);
1123 #define MAX_PREALLOC_SIZE (32 * 1024 * 1024)
1125 static int avs_component_construct(struct snd_soc_component *component,
1126 struct snd_soc_pcm_runtime *rtd)
1128 struct snd_soc_dai *dai = snd_soc_rtd_to_cpu(rtd, 0);
1129 struct snd_pcm *pcm = rtd->pcm;
1131 if (dai->driver->playback.channels_min)
1132 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
1133 SNDRV_DMA_TYPE_DEV_SG, component->dev, 0,
1136 if (dai->driver->capture.channels_min)
1137 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
1138 SNDRV_DMA_TYPE_DEV_SG, component->dev, 0,
1144 static const struct snd_soc_component_driver avs_component_driver = {
1146 .probe = avs_component_probe,
1147 .remove = avs_component_remove,
1148 .suspend = avs_component_suspend,
1149 .resume = avs_component_resume,
1150 .open = avs_component_open,
1151 .pointer = avs_component_pointer,
1152 .mmap = avs_component_mmap,
1153 .pcm_construct = avs_component_construct,
1154 .module_get_upon_open = 1, /* increment refcount when a pcm is opened */
1155 .topology_name_prefix = "intel/avs",
1158 int avs_soc_component_register(struct device *dev, const char *name,
1159 const struct snd_soc_component_driver *drv,
1160 struct snd_soc_dai_driver *cpu_dais, int num_cpu_dais)
1162 struct avs_soc_component *acomp;
1165 acomp = devm_kzalloc(dev, sizeof(*acomp), GFP_KERNEL);
1169 ret = snd_soc_component_initialize(&acomp->base, drv, dev);
1173 /* force name change after ASoC is done with its init */
1174 acomp->base.name = name;
1175 INIT_LIST_HEAD(&acomp->node);
1177 return snd_soc_add_component(&acomp->base, cpu_dais, num_cpu_dais);
1180 static struct snd_soc_dai_driver dmic_cpu_dais[] = {
1183 .ops = &avs_dai_nonhda_be_ops,
1185 .stream_name = "DMIC Rx",
1188 .rates = SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_48000,
1189 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
1193 .name = "DMIC WoV Pin",
1194 .ops = &avs_dai_nonhda_be_ops,
1196 .stream_name = "DMIC WoV Rx",
1199 .rates = SNDRV_PCM_RATE_16000,
1200 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1205 int avs_dmic_platform_register(struct avs_dev *adev, const char *name)
1207 return avs_soc_component_register(adev->dev, name, &avs_component_driver, dmic_cpu_dais,
1208 ARRAY_SIZE(dmic_cpu_dais));
1211 static const struct snd_soc_dai_driver i2s_dai_template = {
1212 .ops = &avs_dai_nonhda_be_ops,
1216 .rates = SNDRV_PCM_RATE_8000_192000 |
1217 SNDRV_PCM_RATE_KNOT,
1218 .formats = SNDRV_PCM_FMTBIT_S16_LE |
1219 SNDRV_PCM_FMTBIT_S24_LE |
1220 SNDRV_PCM_FMTBIT_S32_LE,
1225 .rates = SNDRV_PCM_RATE_8000_192000 |
1226 SNDRV_PCM_RATE_KNOT,
1227 .formats = SNDRV_PCM_FMTBIT_S16_LE |
1228 SNDRV_PCM_FMTBIT_S24_LE |
1229 SNDRV_PCM_FMTBIT_S32_LE,
1233 int avs_i2s_platform_register(struct avs_dev *adev, const char *name, unsigned long port_mask,
1234 unsigned long *tdms)
1236 struct snd_soc_dai_driver *cpus, *dai;
1237 size_t ssp_count, cpu_count;
1240 ssp_count = adev->hw_cfg.i2s_caps.ctrl_count;
1243 for_each_set_bit(i, &port_mask, ssp_count)
1244 if (!tdms || test_bit(0, &tdms[i]))
1247 for_each_set_bit(i, &port_mask, ssp_count)
1248 cpu_count += hweight_long(tdms[i]);
1250 cpus = devm_kzalloc(adev->dev, sizeof(*cpus) * cpu_count, GFP_KERNEL);
1255 for_each_set_bit(i, &port_mask, ssp_count) {
1256 if (!tdms || test_bit(0, &tdms[i])) {
1257 memcpy(dai, &i2s_dai_template, sizeof(*dai));
1260 devm_kasprintf(adev->dev, GFP_KERNEL, "SSP%d Pin", i);
1261 dai->playback.stream_name =
1262 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d Tx", i);
1263 dai->capture.stream_name =
1264 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d Rx", i);
1266 if (!dai->name || !dai->playback.stream_name || !dai->capture.stream_name)
1275 for_each_set_bit(i, &port_mask, ssp_count) {
1276 for_each_set_bit(j, &tdms[i], ssp_count) {
1277 memcpy(dai, &i2s_dai_template, sizeof(*dai));
1280 devm_kasprintf(adev->dev, GFP_KERNEL, "SSP%d:%d Pin", i, j);
1281 dai->playback.stream_name =
1282 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d:%d Tx", i, j);
1283 dai->capture.stream_name =
1284 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d:%d Rx", i, j);
1286 if (!dai->name || !dai->playback.stream_name || !dai->capture.stream_name)
1293 return avs_soc_component_register(adev->dev, name, &avs_component_driver, cpus, cpu_count);
1296 /* HD-Audio CPU DAI template */
1297 static const struct snd_soc_dai_driver hda_cpu_dai = {
1298 .ops = &avs_dai_hda_be_ops,
1302 .rates = SNDRV_PCM_RATE_8000_192000,
1303 .formats = SNDRV_PCM_FMTBIT_S16_LE |
1304 SNDRV_PCM_FMTBIT_S24_LE |
1305 SNDRV_PCM_FMTBIT_S32_LE,
1310 .rates = SNDRV_PCM_RATE_8000_192000,
1311 .formats = SNDRV_PCM_FMTBIT_S16_LE |
1312 SNDRV_PCM_FMTBIT_S24_LE |
1313 SNDRV_PCM_FMTBIT_S32_LE,
1317 static void avs_component_hda_unregister_dais(struct snd_soc_component *component)
1319 struct snd_soc_acpi_mach *mach;
1320 struct snd_soc_dai *dai, *save;
1321 struct hda_codec *codec;
1324 mach = dev_get_platdata(component->card->dev);
1325 codec = mach->pdata;
1326 sprintf(name, "%s-cpu", dev_name(&codec->core.dev));
1328 for_each_component_dais_safe(component, dai, save) {
1331 if (!strstr(dai->driver->name, name))
1334 for_each_pcm_streams(stream)
1335 snd_soc_dapm_free_widget(snd_soc_dai_get_widget(dai, stream));
1337 snd_soc_unregister_dai(dai);
1341 static int avs_component_hda_probe(struct snd_soc_component *component)
1343 struct snd_soc_dapm_context *dapm;
1344 struct snd_soc_dai_driver *dais;
1345 struct snd_soc_acpi_mach *mach;
1346 struct hda_codec *codec;
1347 struct hda_pcm *pcm;
1349 int pcm_count = 0, ret, i;
1351 mach = dev_get_platdata(component->card->dev);
1355 codec = mach->pdata;
1356 if (list_empty(&codec->pcm_list_head))
1358 list_for_each_entry(pcm, &codec->pcm_list_head, list)
1361 dais = devm_kcalloc(component->dev, pcm_count, sizeof(*dais),
1366 cname = dev_name(&codec->core.dev);
1367 dapm = snd_soc_component_get_dapm(component);
1368 pcm = list_first_entry(&codec->pcm_list_head, struct hda_pcm, list);
1370 for (i = 0; i < pcm_count; i++, pcm = list_next_entry(pcm, list)) {
1371 struct snd_soc_dai *dai;
1373 memcpy(&dais[i], &hda_cpu_dai, sizeof(*dais));
1375 dais[i].name = devm_kasprintf(component->dev, GFP_KERNEL,
1376 "%s-cpu%d", cname, i);
1377 if (!dais[i].name) {
1382 if (pcm->stream[0].substreams) {
1383 dais[i].playback.stream_name =
1384 devm_kasprintf(component->dev, GFP_KERNEL,
1385 "%s-cpu%d Tx", cname, i);
1386 if (!dais[i].playback.stream_name) {
1392 if (pcm->stream[1].substreams) {
1393 dais[i].capture.stream_name =
1394 devm_kasprintf(component->dev, GFP_KERNEL,
1395 "%s-cpu%d Rx", cname, i);
1396 if (!dais[i].capture.stream_name) {
1402 dai = snd_soc_register_dai(component, &dais[i], false);
1404 dev_err(component->dev, "register dai for %s failed\n",
1410 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
1412 dev_err(component->dev, "create widgets failed: %d\n",
1418 ret = avs_component_probe(component);
1421 avs_component_hda_unregister_dais(component);
1426 static void avs_component_hda_remove(struct snd_soc_component *component)
1428 avs_component_hda_unregister_dais(component);
1429 avs_component_remove(component);
1432 static int avs_component_hda_open(struct snd_soc_component *component,
1433 struct snd_pcm_substream *substream)
1435 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1436 struct hdac_ext_stream *link_stream;
1437 struct hda_codec *codec;
1439 if (!rtd->dai_link->no_pcm) {
1440 struct snd_pcm_hardware hwparams = avs_pcm_hardware;
1441 struct snd_soc_pcm_runtime *be;
1442 struct snd_soc_dpcm *dpcm;
1443 int dir = substream->stream;
1446 * Support the DPCM reparenting while still fulfilling expectations of HDAudio
1447 * common code - a valid stream pointer at substream->runtime->private_data -
1448 * by having all FEs point to the same private data.
1450 for_each_dpcm_be(rtd, dir, dpcm) {
1451 struct snd_pcm_substream *be_substream;
1454 if (be->dpcm[dir].users == 1)
1457 be_substream = snd_soc_dpcm_get_substream(be, dir);
1458 substream->runtime->private_data = be_substream->runtime->private_data;
1462 /* RESUME unsupported for de-coupled HD-Audio capture. */
1463 if (dir == SNDRV_PCM_STREAM_CAPTURE)
1464 hwparams.info &= ~SNDRV_PCM_INFO_RESUME;
1466 return snd_soc_set_runtime_hwparams(substream, &hwparams);
1469 codec = dev_to_hda_codec(snd_soc_rtd_to_codec(rtd, 0)->dev);
1470 link_stream = snd_hdac_ext_stream_assign(&codec->bus->core, substream,
1471 HDAC_EXT_STREAM_TYPE_LINK);
1475 substream->runtime->private_data = link_stream;
1479 static int avs_component_hda_close(struct snd_soc_component *component,
1480 struct snd_pcm_substream *substream)
1482 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1483 struct hdac_ext_stream *link_stream;
1485 /* only BE DAI links are handled here */
1486 if (!rtd->dai_link->no_pcm)
1489 link_stream = substream->runtime->private_data;
1490 snd_hdac_ext_stream_release(link_stream, HDAC_EXT_STREAM_TYPE_LINK);
1491 substream->runtime->private_data = NULL;
1496 static const struct snd_soc_component_driver avs_hda_component_driver = {
1497 .name = "avs-hda-pcm",
1498 .probe = avs_component_hda_probe,
1499 .remove = avs_component_hda_remove,
1500 .suspend = avs_component_suspend,
1501 .resume = avs_component_resume,
1502 .open = avs_component_hda_open,
1503 .close = avs_component_hda_close,
1504 .pointer = avs_component_pointer,
1505 .mmap = avs_component_mmap,
1506 .pcm_construct = avs_component_construct,
1508 * hda platform component's probe() is dependent on
1509 * codec->pcm_list_head, it needs to be initialized after codec
1510 * component. remove_order is here for completeness sake
1512 .probe_order = SND_SOC_COMP_ORDER_LATE,
1513 .remove_order = SND_SOC_COMP_ORDER_EARLY,
1514 .module_get_upon_open = 1,
1515 .topology_name_prefix = "intel/avs",
1518 int avs_hda_platform_register(struct avs_dev *adev, const char *name)
1520 return avs_soc_component_register(adev->dev, name,
1521 &avs_hda_component_driver, NULL, 0);