Lines Matching +full:ignore +full:- +full:suspend +full:- +full:widgets
1 // SPDX-License-Identifier: GPL-2.0-only
3 // Copyright(c) 2021-2022 Intel Corporation
14 #include <sound/soc-acpi.h>
15 #include <sound/soc-acpi-intel-match.h>
16 #include <sound/soc-component.h>
29 /* LINK-stream utilized in BE operations while HOST in FE ones. */
57 dp = list_first_entry_or_null(&dw->edges[dir], typeof(*dp), list_node[dir]);
62 dw = (dp->source == dw) ? dp->sink : dp->source;
64 return dw->priv;
71 snd_pcm_period_elapsed(data->substream);
80 schedule_work(&data->period_elapsed_work);
86 struct snd_pcm_runtime *runtime = substream->runtime;
96 r = &(data->rate_list);
97 c = &(data->channels_list);
98 s = &(data->sample_bits_list);
100 ret = avs_path_set_constraint(data->adev, data->template, r, c, s);
122 struct avs_dev *adev = to_avs_dev(dai->component->dev);
126 template = avs_dai_find_path_template(dai, !rtd->dai_link->no_pcm, substream->stream);
128 dev_err(dai->dev, "no %s path for dai %s, invalid tplg?\n",
129 snd_pcm_stream_str(substream), dai->name);
130 return -EINVAL;
135 return -ENOMEM;
137 data->substream = substream;
138 data->template = template;
139 data->adev = adev;
140 INIT_WORK(&data->period_elapsed_work, avs_period_elapsed_work);
143 if (rtd->dai_link->ignore_suspend)
144 adev->num_lp_paths++;
156 if (rtd->dai_link->ignore_suspend)
157 data->adev->num_lp_paths--;
159 kfree(data->rate_list.list);
160 kfree(data->channels_list.list);
161 kfree(data->sample_bits_list.list);
178 dev_dbg(dai->dev, "%s FE hw_params str %p rtd %p",
179 __func__, substream, substream->runtime);
180 dev_dbg(dai->dev, "rate %d chn %d vbd %d bd %d\n",
184 dev_dbg(dai->dev, "%s BE hw_params str %p rtd %p",
185 __func__, substream, substream->runtime);
186 dev_dbg(dai->dev, "rate %d chn %d vbd %d bd %d\n",
190 path = avs_path_create(data->adev, dma_id, data->template, fe_hw_params, be_hw_params);
193 dev_err(dai->dev, "create path failed: %d\n", ret);
197 data->path = path;
211 for_each_dpcm_fe(be, substream->stream, dpcm) {
212 fe = dpcm->fe;
213 fe_hw_params = &fe->dpcm[substream->stream].hw_params;
225 if (!data->path)
228 ret = avs_path_reset(data->path);
230 dev_err(dai->dev, "reset path failed: %d\n", ret);
234 ret = avs_path_pause(data->path);
236 dev_err(dai->dev, "pause path failed: %d\n", ret);
246 if (data->path)
249 /* Actual port-id comes from topology. */
257 dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
260 if (data->path) {
261 avs_path_free(data->path);
262 data->path = NULL;
279 if (rtd->dai_link->ignore_suspend)
284 ret = avs_path_pause(data->path);
286 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
290 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO);
292 dev_err(dai->dev, "run BE path failed: %d\n", ret);
296 if (rtd->dai_link->ignore_suspend)
301 ret = avs_path_pause(data->path);
303 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
305 ret = avs_path_reset(data->path);
307 dev_err(dai->dev, "reset BE path failed: %d\n", ret);
311 ret = -EINVAL;
339 link_stream = snd_hdac_ext_stream_assign(&data->adev->base.core, substream,
343 return -EBUSY;
346 data->link_stream = link_stream;
347 data->link = link;
359 codec = dev_to_hda_codec(snd_soc_rtd_to_codec(rtd, 0)->dev);
361 link = snd_hdac_ext_bus_get_hlink_by_addr(&codec->bus->core, codec->core.addr);
363 return -EINVAL;
368 substream->runtime->private_data = data->link_stream;
376 struct avs_dev *adev = to_avs_dev(dai->component->dev);
379 link = snd_hdac_ext_bus_get_hlink_by_id(&adev->base.core, AZX_REG_ML_LEPTR_ID_INTEL_SSP);
381 return -EINVAL;
387 struct avs_dev *adev = to_avs_dev(dai->component->dev);
390 link = snd_hdac_ext_bus_get_hlink_by_id(&adev->base.core, AZX_REG_ML_LEPTR_ID_INTEL_DMIC);
392 return -EINVAL;
400 snd_hdac_ext_stream_release(data->link_stream, HDAC_EXT_STREAM_TYPE_LINK);
401 substream->runtime->private_data = NULL;
409 snd_hdac_ext_stream_release(data->link_stream, HDAC_EXT_STREAM_TYPE_LINK);
419 if (data->path)
423 hdac_stream(data->link_stream)->stream_tag - 1);
432 if (!data->path)
435 link_stream = data->link_stream;
436 link_stream->link_prepared = false;
437 avs_path_free(data->path);
438 data->path = NULL;
440 /* clear link <-> stream mapping */
441 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
442 snd_hdac_ext_bus_link_clear_stream_id(data->link,
443 hdac_stream(link_stream)->stream_tag);
460 link_stream = data->link_stream;
461 p = &be->dpcm[substream->stream].hw_params;
463 if (link_stream->link_prepared)
466 stream_info = snd_soc_dai_get_pcm_stream(dai, substream->stream);
468 stream_info->sig_bits);
471 snd_hdac_ext_stream_decouple(&data->adev->base.core, link_stream, true);
475 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
476 snd_hdac_ext_bus_link_set_stream_id(data->link,
477 hdac_stream(link_stream)->stream_tag);
483 link_stream->link_prepared = true;
494 dev_dbg(dai->dev, "entry %s cmd=%d\n", __func__, cmd);
500 if (rtd->dai_link->ignore_suspend)
505 snd_hdac_ext_stream_start(data->link_stream);
507 ret = avs_path_pause(data->path);
509 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
513 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO);
515 dev_err(dai->dev, "run BE path failed: %d\n", ret);
519 if (rtd->dai_link->ignore_suspend)
524 ret = avs_path_pause(data->path);
526 dev_err(dai->dev, "pause BE path failed: %d\n", ret);
528 snd_hdac_ext_stream_clear(data->link_stream);
530 ret = avs_path_reset(data->path);
532 dev_err(dai->dev, "reset BE path failed: %d\n", ret);
536 ret = -EINVAL;
572 struct snd_interval *interval = hw_param_interval(params, rule->var);
576 to.integer = interval->integer;
577 to.max = interval->max;
584 if (rule->var == SNDRV_PCM_HW_PARAM_PERIOD_SIZE)
592 struct snd_pcm_runtime *runtime = substream->runtime;
599 /* Avoid wrap-around with wall-clock. */
607 SNDRV_PCM_HW_PARAM_RATE, -1);
610 SNDRV_PCM_HW_PARAM_RATE, -1);
631 bus = &data->adev->base.core;
636 return -EBUSY;
639 data->host_stream = host_stream;
642 dev_dbg(dai->dev, "%s fe STARTUP tag %d str %p",
643 __func__, hdac_stream(host_stream)->stream_tag, substream);
654 snd_hdac_ext_stream_release(data->host_stream, HDAC_EXT_STREAM_TYPE_HOST);
669 if (data->path)
672 host_stream = data->host_stream;
674 hdac_stream(host_stream)->bufsize = 0;
675 hdac_stream(host_stream)->period_bytes = 0;
676 hdac_stream(host_stream)->format_val = 0;
680 for_each_dpcm_be(fe, substream->stream, dpcm) {
681 be = dpcm->be;
682 be_hw_params = &be->dpcm[substream->stream].hw_params;
686 hdac_stream(host_stream)->stream_tag - 1);
690 ret = avs_path_bind(data->path);
692 dev_err(dai->dev, "bind FE <-> BE failed: %d\n", ret);
699 avs_path_free(data->path);
700 data->path = NULL;
712 dev_dbg(dai->dev, "%s fe HW_FREE str %p rtd %p",
713 __func__, substream, substream->runtime);
716 if (!data->path)
719 host_stream = data->host_stream;
721 ret = avs_path_unbind(data->path);
723 dev_err(dai->dev, "unbind FE <-> BE failed: %d\n", ret);
725 avs_path_free(data->path);
726 data->path = NULL;
728 hdac_stream(host_stream)->prepared = false;
745 struct snd_pcm_runtime *runtime = substream->runtime;
755 host_stream = data->host_stream;
757 if (hdac_stream(host_stream)->prepared)
760 bus = hdac_stream(host_stream)->bus;
761 snd_hdac_ext_stream_decouple(bus, data->host_stream, true);
764 stream_info = snd_soc_dai_get_pcm_stream(dai, substream->stream);
765 bits = snd_hdac_stream_format_bits(runtime->format, runtime->subformat,
766 stream_info->sig_bits);
767 format_val = snd_hdac_stream_format(runtime->channels, bits, runtime->rate);
781 hdac_stream(host_stream)->prepared = true;
791 list_for_each_entry(pos, &bus->stream_list, list) {
792 if (pos->running) {
804 if (hdac_stream(host_stream)->direction == SNDRV_PCM_STREAM_CAPTURE)
813 * re-enable L1SEN.
815 if (list_entry_is_head(pos, &bus->stream_list, list) &&
816 first_running->direction == SNDRV_PCM_STREAM_CAPTURE)
826 list_for_each_entry(pos, &bus->stream_list, list) {
828 continue; /* ignore stream that is about to be stopped */
829 if (pos->running) {
838 * re-enable L1SEN.
842 if (hdac_stream(host_stream)->direction == SNDRV_PCM_STREAM_CAPTURE)
851 if (list_entry_is_head(pos, &bus->stream_list, list) &&
852 first_running->direction == SNDRV_PCM_STREAM_CAPTURE)
868 host_stream = data->host_stream;
869 bus = hdac_stream(host_stream)->bus;
873 if (rtd->dai_link->ignore_suspend)
878 spin_lock_irqsave(&bus->reg_lock, flags);
880 spin_unlock_irqrestore(&bus->reg_lock, flags);
882 /* Timeout on DRSM poll shall not stop the resume so ignore the result. */
886 ret = avs_path_pause(data->path);
888 dev_err(dai->dev, "pause FE path failed: %d\n", ret);
892 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO);
894 dev_err(dai->dev, "run FE path failed: %d\n", ret);
899 if (rtd->dai_link->ignore_suspend)
904 ret = avs_path_pause(data->path);
906 dev_err(dai->dev, "pause FE path failed: %d\n", ret);
908 spin_lock_irqsave(&bus->reg_lock, flags);
910 spin_unlock_irqrestore(&bus->reg_lock, flags);
912 ret = avs_path_reset(data->path);
914 dev_err(dai->dev, "reset FE path failed: %d\n", ret);
918 ret = -EINVAL;
937 struct snd_soc_component *component = file->private_data;
938 struct snd_soc_card *card = component->card;
939 struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev);
943 len = scnprintf(buf, sizeof(buf), "%s/%s\n", component->driver->topology_name_prefix,
944 mach->tplg_filename);
957 struct avs_tplg *tplg = acomp->tplg;
958 struct avs_dev *adev = to_avs_dev(acomp->base.dev);
961 if (!tplg->num_libs)
965 ret = pm_runtime_resume_and_get(adev->dev);
973 ret = avs_dsp_load_libraries(adev, tplg->libs, tplg->num_libs);
982 pm_runtime_put_autosuspend(adev->dev);
989 struct snd_soc_card *card = component->card;
996 dev_dbg(card->dev, "probing %s card %s\n", component->name, card->name);
997 mach = dev_get_platdata(card->dev);
999 adev = to_avs_dev(component->dev);
1001 acomp->tplg = avs_tplg_new(component);
1002 if (!acomp->tplg)
1003 return -ENOMEM;
1005 if (!mach->tplg_filename)
1009 filename = kasprintf(GFP_KERNEL, "%s/%s", component->driver->topology_name_prefix,
1010 mach->tplg_filename);
1012 return -ENOMEM;
1016 if (ret == -ENOENT && !strncmp(mach->tplg_filename, "hda-", 4)) {
1019 if (sscanf(mach->tplg_filename, "hda-%08x-tplg.bin", &vendor_id) != 1)
1023 mach->tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL,
1024 "hda-8086-generic-tplg.bin");
1026 mach->tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL,
1027 "hda-generic-tplg.bin");
1028 if (!mach->tplg_filename)
1029 return -ENOMEM;
1030 filename = kasprintf(GFP_KERNEL, "%s/%s", component->driver->topology_name_prefix,
1031 mach->tplg_filename);
1033 return -ENOMEM;
1035 dev_info(card->dev, "trying to load fallback topology %s\n", mach->tplg_filename);
1044 dev_err(card->dev, "libraries loading failed: %d\n", ret);
1049 debugfs_create_file("topology_name", 0444, component->debugfs_root, component,
1052 mutex_lock(&adev->comp_list_mutex);
1053 list_add_tail(&acomp->node, &adev->comp_list);
1054 mutex_unlock(&adev->comp_list_mutex);
1067 struct avs_dev *adev = to_avs_dev(component->dev);
1070 mach = dev_get_platdata(component->card->dev);
1072 mutex_lock(&adev->comp_list_mutex);
1073 list_del(&acomp->node);
1074 mutex_unlock(&adev->comp_list_mutex);
1076 if (mach->tplg_filename) {
1079 dev_err(component->dev, "unload topology failed: %d\n", ret);
1089 substream = data->substream;
1092 ret = dai->driver->ops->hw_params(substream, &rtd->dpcm[substream->stream].hw_params, dai);
1094 dev_err(dai->dev, "hw_params on resume failed: %d\n", ret);
1106 host_stream = data->host_stream;
1108 bus = hdac_stream(host_stream)->bus;
1111 snd_hdac_stream_drsm_enable(bus, true, hstream->index);
1113 ret = dai->driver->ops->prepare(data->substream, dai);
1115 dev_err(dai->dev, "prepare FE on resume failed: %d\n", ret);
1119 writel(host_stream->pphcllpl, host_stream->pphc_addr + AZX_REG_PPHCLLPL);
1120 writel(host_stream->pphcllpu, host_stream->pphc_addr + AZX_REG_PPHCLLPU);
1121 writel(host_stream->pphcldpl, host_stream->pphc_addr + AZX_REG_PPHCLDPL);
1122 writel(host_stream->pphcldpu, host_stream->pphc_addr + AZX_REG_PPHCLDPU);
1125 snd_hdac_stream_set_lpib(hstream, hstream->lpib);
1126 snd_hdac_stream_set_dpibr(bus, hstream, hstream->lpib);
1135 ret = dai->driver->ops->prepare(data->substream, dai);
1137 dev_err(dai->dev, "prepare BE on resume failed: %d\n", ret);
1147 host_stream = data->host_stream;
1150 hdac_stream(host_stream)->lpib = snd_hdac_stream_get_pos_lpib(hdac_stream(host_stream));
1151 host_stream->pphcllpl = readl(host_stream->pphc_addr + AZX_REG_PPHCLLPL);
1152 host_stream->pphcllpu = readl(host_stream->pphc_addr + AZX_REG_PPHCLLPU);
1153 host_stream->pphcldpl = readl(host_stream->pphc_addr + AZX_REG_PPHCLDPL);
1154 host_stream->pphcldpu = readl(host_stream->pphc_addr + AZX_REG_PPHCLDPU);
1156 ret = __avs_dai_fe_hw_free(data->substream, dai);
1158 dev_err(dai->dev, "hw_free FE on suspend failed: %d\n", ret);
1167 ret = dai->driver->ops->hw_free(data->substream, dai);
1169 dev_err(dai->dev, "hw_free BE on suspend failed: %d\n", ret);
1185 rtd = snd_soc_substream_to_rtd(data->substream);
1186 if (rtd->dai_link->no_pcm == be && !rtd->dai_link->ignore_suspend) {
1189 __snd_pcm_set_state(data->substream->runtime,
1198 rtd = snd_soc_substream_to_rtd(data->substream);
1199 if (rtd->dai_link->no_pcm == be && !rtd->dai_link->ignore_suspend) {
1202 __snd_pcm_set_state(data->substream->runtime,
1307 if (rtd->dai_link->no_pcm)
1315 return readl(hdac_stream(stream)->bus->remap_addr + AZX_REG_VS_SDXDPIB_XBASE +
1316 (AZX_REG_VS_SDXDPIB_XINTERVAL * hdac_stream(stream)->index));
1328 if (!data->host_stream)
1331 host_stream = data->host_stream;
1334 if (pos >= hdac_stream(host_stream)->bufsize)
1337 return bytes_to_frames(substream->runtime, pos);
1353 struct snd_pcm *pcm = rtd->pcm;
1355 if (dai->driver->playback.channels_min)
1356 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
1357 SNDRV_DMA_TYPE_DEV_SG, component->dev, 0,
1360 if (dai->driver->capture.channels_min)
1361 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
1362 SNDRV_DMA_TYPE_DEV_SG, component->dev, 0,
1369 .name = "avs-pcm",
1372 .suspend = avs_component_suspend,
1391 return -ENOMEM;
1393 acomp->base.name = devm_kstrdup(dev, name, GFP_KERNEL);
1394 if (!acomp->base.name)
1395 return -ENOMEM;
1397 INIT_LIST_HEAD(&acomp->node);
1399 drv->use_dai_pcm_id = !obsolete_card_names;
1401 ret = snd_soc_component_initialize(&acomp->base, drv, dev);
1405 return snd_soc_add_component(&acomp->base, cpu_dais, num_cpu_dais);
1442 return avs_register_component(adev->dev, name, &avs_component_driver, dmic_cpu_dais,
1483 ssp_count = adev->hw_cfg.i2s_caps.ctrl_count;
1497 cpus = devm_kcalloc(adev->dev, cpu_count, sizeof(*cpus), GFP_KERNEL);
1499 return -ENOMEM;
1506 dai->name =
1507 devm_kasprintf(adev->dev, GFP_KERNEL, "SSP%d Pin", i);
1508 dai->playback.stream_name =
1509 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d Tx", i);
1510 dai->capture.stream_name =
1511 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d Rx", i);
1513 if (!dai->name || !dai->playback.stream_name || !dai->capture.stream_name)
1514 return -ENOMEM;
1515 dai->ops = ops;
1527 dai->name =
1528 devm_kasprintf(adev->dev, GFP_KERNEL, "SSP%d:%d Pin", i, j);
1529 dai->playback.stream_name =
1530 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d:%d Tx", i, j);
1531 dai->capture.stream_name =
1532 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d:%d Rx", i, j);
1534 if (!dai->name || !dai->playback.stream_name || !dai->capture.stream_name)
1535 return -ENOMEM;
1536 dai->ops = ops;
1542 return avs_register_component(adev->dev, name, &avs_component_driver, cpus, cpu_count);
1545 /* HD-Audio CPU DAI template */
1578 mach = dev_get_platdata(component->card->dev);
1579 pdata = mach->pdata;
1580 codec = pdata->codec;
1581 snprintf(name, sizeof(name), "%s-cpu", dev_name(&codec->core.dev));
1586 if (!strstr(dai->driver->name, name))
1607 mach = dev_get_platdata(component->card->dev);
1609 return -EINVAL;
1611 pdata = mach->pdata;
1612 codec = pdata->codec;
1613 if (list_empty(&codec->pcm_list_head))
1614 return -EINVAL;
1615 list_for_each_entry(pcm, &codec->pcm_list_head, list)
1618 dais = devm_kcalloc(component->dev, pcm_count, sizeof(*dais),
1621 return -ENOMEM;
1623 cname = dev_name(&codec->core.dev);
1625 pcm = list_first_entry(&codec->pcm_list_head, struct hda_pcm, list);
1632 dais[i].name = devm_kasprintf(component->dev, GFP_KERNEL,
1633 "%s-cpu%d", cname, i);
1635 ret = -ENOMEM;
1639 if (pcm->stream[0].substreams) {
1641 devm_kasprintf(component->dev, GFP_KERNEL,
1642 "%s-cpu%d Tx", cname, i);
1644 ret = -ENOMEM;
1649 dais[i].playback.formats = pcm->stream[0].formats;
1650 dais[i].playback.subformats = pcm->stream[0].subformats;
1651 dais[i].playback.rates = pcm->stream[0].rates;
1652 dais[i].playback.channels_min = pcm->stream[0].channels_min;
1653 dais[i].playback.channels_max = pcm->stream[0].channels_max;
1654 dais[i].playback.sig_bits = pcm->stream[0].maxbps;
1658 if (pcm->stream[1].substreams) {
1660 devm_kasprintf(component->dev, GFP_KERNEL,
1661 "%s-cpu%d Rx", cname, i);
1663 ret = -ENOMEM;
1668 dais[i].capture.formats = pcm->stream[1].formats;
1669 dais[i].capture.subformats = pcm->stream[1].subformats;
1670 dais[i].capture.rates = pcm->stream[1].rates;
1671 dais[i].capture.channels_min = pcm->stream[1].channels_min;
1672 dais[i].capture.channels_max = pcm->stream[1].channels_max;
1673 dais[i].capture.sig_bits = pcm->stream[1].maxbps;
1679 dev_err(component->dev, "register dai for %s failed\n",
1680 pcm->name);
1681 ret = -EINVAL;
1687 dev_err(component->dev, "create widgets failed: %d\n",
1713 if (!rtd->dai_link->no_pcm) {
1717 int dir = substream->stream;
1721 * common code - a valid stream pointer at substream->runtime->private_data -
1727 be = dpcm->be;
1728 if (be->dpcm[dir].users == 1)
1732 substream->runtime->private_data = be_substream->runtime->private_data;
1736 /* RESUME unsupported for de-coupled HD-Audio capture. */
1747 .name = "avs-hda-pcm",
1750 .suspend = avs_component_suspend,
1758 * codec->pcm_list_head, it needs to be initialized after codec
1769 return avs_register_component(adev->dev, name, &avs_hda_component_driver, NULL, 0);