sound/soc/sof/intel/hda-dai.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 //
   3 // This file is provided under a dual BSD/GPLv2 license.  When using or
   4 // redistributing this file, you may do so under either license.
   5 //
   6 // Copyright(c) 2018 Intel Corporation
   7 //
   8 // Authors: Keyon Jie <yang.jie@linux.intel.com>
   9 //
  10
  11 #include <sound/pcm_params.h>
  12 #include <sound/hdaudio_ext.h>
  13 #include <sound/hda-mlink.h>
  14 #include <sound/hda_register.h>
  15 #include <sound/intel-nhlt.h>
  16 #include <sound/sof/ipc4/header.h>
  17 #include <uapi/sound/sof/header.h>
  18 #include "../ipc4-priv.h"
  19 #include "../ipc4-topology.h"
  20 #include "../sof-priv.h"
  21 #include "../sof-audio.h"
  22 #include "hda.h"
  23
  24 /*
  25  * The default method is to fetch NHLT from BIOS. With this parameter set
  26  * it is possible to override that with NHLT in the SOF topology manifest.
  27  */
  28 static bool hda_use_tplg_nhlt;
  29 module_param_named(sof_use_tplg_nhlt, hda_use_tplg_nhlt, bool, 0444);
  30 MODULE_PARM_DESC(sof_use_tplg_nhlt, "SOF topology nhlt override");
  31
  32 int hda_dai_config(struct snd_soc_dapm_widget *w, unsigned int flags,
  33                    struct snd_sof_dai_config_data *data)
  34 {
  35         struct snd_sof_widget *swidget = w->dobj.private;
  36         const struct sof_ipc_tplg_ops *tplg_ops;
  37         struct snd_sof_dev *sdev;
  38         int ret;
  39
  40         if (!swidget)
  41                 return 0;
  42
  43         sdev = widget_to_sdev(w);
  44         tplg_ops = sof_ipc_get_ops(sdev, tplg);
  45
  46         if (tplg_ops && tplg_ops->dai_config) {
  47                 ret = tplg_ops->dai_config(sdev, swidget, flags, data);
  48                 if (ret < 0) {
  49                         dev_err(sdev->dev, "DAI config with flags %x failed for widget %s\n",
  50                                 flags, w->name);
  51                         return ret;
  52                 }
  53         }
  54
  55         return 0;
  56 }
  57 EXPORT_SYMBOL_NS(hda_dai_config, SND_SOC_SOF_INTEL_HDA_COMMON);
  58
  59 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_LINK)
  60
  61 static struct snd_sof_dev *dai_to_sdev(struct snd_pcm_substream *substream,
  62                                        struct snd_soc_dai *cpu_dai)
  63 {
  64         struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
  65
  66         return widget_to_sdev(w);
  67 }
  68
  69 static const struct hda_dai_widget_dma_ops *
  70 hda_dai_get_ops(struct snd_pcm_substream *substream, struct snd_soc_dai *cpu_dai)
  71 {
  72         struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
  73         struct snd_sof_widget *swidget = w->dobj.private;
  74         struct snd_sof_dev *sdev;
  75         struct snd_sof_dai *sdai;
  76
  77         sdev = widget_to_sdev(w);
  78
  79         if (!swidget) {
  80                 dev_err(sdev->dev, "%s: swidget is NULL\n", __func__);
  81                 return NULL;
  82         }
  83
  84         if (sdev->dspless_mode_selected)
  85                 return hda_select_dai_widget_ops(sdev, swidget);
  86
  87         sdai = swidget->private;
  88
  89         /* select and set the DAI widget ops if not set already */
  90         if (!sdai->platform_private) {
  91                 const struct hda_dai_widget_dma_ops *ops =
  92                         hda_select_dai_widget_ops(sdev, swidget);
  93                 if (!ops)
  94                         return NULL;
  95
  96                 /* check if mandatory ops are set */
  97                 if (!ops || !ops->get_hext_stream)
  98                         return NULL;
  99
 100                 sdai->platform_private = ops;
 101         }
 102
 103         return sdai->platform_private;
 104 }
 105
 106 int hda_link_dma_cleanup(struct snd_pcm_substream *substream, struct hdac_ext_stream *hext_stream,
 107                          struct snd_soc_dai *cpu_dai)
 108 {
 109         const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, cpu_dai);
 110         struct sof_intel_hda_stream *hda_stream;
 111         struct hdac_ext_link *hlink;
 112         struct snd_sof_dev *sdev;
 113         int stream_tag;
 114
 115         if (!ops) {
 116                 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
 117                 return -EINVAL;
 118         }
 119
 120         sdev = dai_to_sdev(substream, cpu_dai);
 121
 122         hlink = ops->get_hlink(sdev, substream);
 123         if (!hlink)
 124                 return -EINVAL;
 125
 126         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 127                 stream_tag = hdac_stream(hext_stream)->stream_tag;
 128                 snd_hdac_ext_bus_link_clear_stream_id(hlink, stream_tag);
 129         }
 130
 131         if (ops->release_hext_stream)
 132                 ops->release_hext_stream(sdev, cpu_dai, substream);
 133
 134         hext_stream->link_prepared = 0;
 135
 136         /* free the host DMA channel reserved by hostless streams */
 137         hda_stream = hstream_to_sof_hda_stream(hext_stream);
 138         hda_stream->host_reserved = 0;
 139
 140         return 0;
 141 }
 142
 143 static int hda_link_dma_hw_params(struct snd_pcm_substream *substream,
 144                                   struct snd_pcm_hw_params *params, struct snd_soc_dai *cpu_dai)
 145 {
 146         const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, cpu_dai);
 147         struct hdac_ext_stream *hext_stream;
 148         struct hdac_stream *hstream;
 149         struct hdac_ext_link *hlink;
 150         struct snd_sof_dev *sdev;
 151         int stream_tag;
 152
 153         if (!ops) {
 154                 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
 155                 return -EINVAL;
 156         }
 157
 158         sdev = dai_to_sdev(substream, cpu_dai);
 159
 160         hlink = ops->get_hlink(sdev, substream);
 161         if (!hlink)
 162                 return -EINVAL;
 163
 164         hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
 165
 166         if (!hext_stream) {
 167                 if (ops->assign_hext_stream)
 168                         hext_stream = ops->assign_hext_stream(sdev, cpu_dai, substream);
 169         }
 170
 171         if (!hext_stream)
 172                 return -EBUSY;
 173
 174         hstream = &hext_stream->hstream;
 175         stream_tag = hstream->stream_tag;
 176
 177         if (hext_stream->hstream.direction == SNDRV_PCM_STREAM_PLAYBACK)
 178                 snd_hdac_ext_bus_link_set_stream_id(hlink, stream_tag);
 179
 180         /* set the hdac_stream in the codec dai */
 181         if (ops->codec_dai_set_stream)
 182                 ops->codec_dai_set_stream(sdev, substream, hstream);
 183
 184         if (ops->reset_hext_stream)
 185                 ops->reset_hext_stream(sdev, hext_stream);
 186
 187         if (ops->calc_stream_format && ops->setup_hext_stream) {
 188                 unsigned int format_val = ops->calc_stream_format(sdev, substream, params);
 189
 190                 ops->setup_hext_stream(sdev, hext_stream, format_val);
 191         }
 192
 193         hext_stream->link_prepared = 1;
 194
 195         return 0;
 196 }
 197
 198 static int __maybe_unused hda_dai_hw_free(struct snd_pcm_substream *substream,
 199                                           struct snd_soc_dai *cpu_dai)
 200 {
 201         const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, cpu_dai);
 202         struct hdac_ext_stream *hext_stream;
 203         struct snd_sof_dev *sdev = dai_to_sdev(substream, cpu_dai);
 204
 205         if (!ops) {
 206                 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
 207                 return -EINVAL;
 208         }
 209
 210         hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
 211         if (!hext_stream)
 212                 return 0;
 213
 214         return hda_link_dma_cleanup(substream, hext_stream, cpu_dai);
 215 }
 216
 217 static int __maybe_unused hda_dai_hw_params_data(struct snd_pcm_substream *substream,
 218                                                  struct snd_pcm_hw_params *params,
 219                                                  struct snd_soc_dai *dai,
 220                                                  struct snd_sof_dai_config_data *data,
 221                                                  unsigned int flags)
 222 {
 223         struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(dai, substream->stream);
 224         const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, dai);
 225         struct hdac_ext_stream *hext_stream;
 226         struct snd_sof_dev *sdev = widget_to_sdev(w);
 227         int ret;
 228
 229         if (!ops) {
 230                 dev_err(sdev->dev, "DAI widget ops not set\n");
 231                 return -EINVAL;
 232         }
 233
 234         hext_stream = ops->get_hext_stream(sdev, dai, substream);
 235         if (hext_stream && hext_stream->link_prepared)
 236                 return 0;
 237
 238         ret = hda_link_dma_hw_params(substream, params, dai);
 239         if (ret < 0)
 240                 return ret;
 241
 242         hext_stream = ops->get_hext_stream(sdev, dai, substream);
 243
 244         flags |= SOF_DAI_CONFIG_FLAGS_2_STEP_STOP << SOF_DAI_CONFIG_FLAGS_QUIRK_SHIFT;
 245         data->dai_data = hdac_stream(hext_stream)->stream_tag - 1;
 246
 247         return hda_dai_config(w, flags, data);
 248 }
 249
 250 static int __maybe_unused hda_dai_hw_params(struct snd_pcm_substream *substream,
 251                                             struct snd_pcm_hw_params *params,
 252                                             struct snd_soc_dai *dai)
 253 {
 254         struct snd_sof_dai_config_data data = { 0 };
 255         unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_PARAMS;
 256
 257         return hda_dai_hw_params_data(substream, params, dai, &data, flags);
 258 }
 259
 260 /*
 261  * In contrast to IPC3, the dai trigger in IPC4 mixes pipeline state changes
 262  * (over IPC channel) and DMA state change (direct host register changes).
 263  */
 264 static int __maybe_unused hda_dai_trigger(struct snd_pcm_substream *substream, int cmd,
 265                                           struct snd_soc_dai *dai)
 266 {
 267         const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, dai);
 268         struct hdac_ext_stream *hext_stream;
 269         struct snd_sof_dev *sdev;
 270         int ret;
 271
 272         if (!ops) {
 273                 dev_err(dai->dev, "DAI widget ops not set\n");
 274                 return -EINVAL;
 275         }
 276
 277         dev_dbg(dai->dev, "cmd=%d dai %s direction %d\n", cmd,
 278                 dai->name, substream->stream);
 279
 280         sdev = dai_to_sdev(substream, dai);
 281
 282         hext_stream = ops->get_hext_stream(sdev, dai, substream);
 283         if (!hext_stream)
 284                 return -EINVAL;
 285
 286         if (ops->pre_trigger) {
 287                 ret = ops->pre_trigger(sdev, dai, substream, cmd);
 288                 if (ret < 0)
 289                         return ret;
 290         }
 291
 292         if (ops->trigger) {
 293                 ret = ops->trigger(sdev, dai, substream, cmd);
 294                 if (ret < 0)
 295                         return ret;
 296         }
 297
 298         if (ops->post_trigger) {
 299                 ret = ops->post_trigger(sdev, dai, substream, cmd);
 300                 if (ret < 0)
 301                         return ret;
 302         }
 303
 304         switch (cmd) {
 305         case SNDRV_PCM_TRIGGER_SUSPEND:
 306                 ret = hda_link_dma_cleanup(substream, hext_stream, dai);
 307                 if (ret < 0) {
 308                         dev_err(sdev->dev, "%s: failed to clean up link DMA\n", __func__);
 309                         return ret;
 310                 }
 311                 break;
 312         default:
 313                 break;
 314         }
 315
 316         return 0;
 317 }
 318
 319 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
 320
 321 static int hda_dai_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
 322 {
 323         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 324         int stream = substream->stream;
 325
 326         return hda_dai_hw_params(substream, &rtd->dpcm[stream].hw_params, dai);
 327 }
 328
 329 static const struct snd_soc_dai_ops hda_dai_ops = {
 330         .hw_params = hda_dai_hw_params,
 331         .hw_free = hda_dai_hw_free,
 332         .trigger = hda_dai_trigger,
 333         .prepare = hda_dai_prepare,
 334 };
 335
 336 #endif
 337
 338 static struct sof_ipc4_copier *widget_to_copier(struct snd_soc_dapm_widget *w)
 339 {
 340         struct snd_sof_widget *swidget = w->dobj.private;
 341         struct snd_sof_dai *sdai = swidget->private;
 342         struct sof_ipc4_copier *ipc4_copier = (struct sof_ipc4_copier *)sdai->private;
 343
 344         return ipc4_copier;
 345 }
 346
 347 static int non_hda_dai_hw_params_data(struct snd_pcm_substream *substream,
 348                                       struct snd_pcm_hw_params *params,
 349                                       struct snd_soc_dai *cpu_dai,
 350                                       struct snd_sof_dai_config_data *data,
 351                                       unsigned int flags)
 352 {
 353         struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
 354         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 355         struct sof_ipc4_dma_config_tlv *dma_config_tlv;
 356         const struct hda_dai_widget_dma_ops *ops;
 357         struct sof_ipc4_dma_config *dma_config;
 358         struct sof_ipc4_copier *ipc4_copier;
 359         struct hdac_ext_stream *hext_stream;
 360         struct hdac_stream *hstream;
 361         struct snd_sof_dev *sdev;
 362         struct snd_soc_dai *dai;
 363         int cpu_dai_id;
 364         int stream_id;
 365         int ret;
 366
 367         ops = hda_dai_get_ops(substream, cpu_dai);
 368         if (!ops) {
 369                 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
 370                 return -EINVAL;
 371         }
 372
 373         /* use HDaudio stream handling */
 374         ret = hda_dai_hw_params_data(substream, params, cpu_dai, data, flags);
 375         if (ret < 0) {
 376                 dev_err(cpu_dai->dev, "%s: hda_dai_hw_params_data failed: %d\n", __func__, ret);
 377                 return ret;
 378         }
 379
 380         sdev = widget_to_sdev(w);
 381         if (sdev->dspless_mode_selected)
 382                 return 0;
 383
 384         /* get stream_id */
 385         hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
 386
 387         if (!hext_stream) {
 388                 dev_err(cpu_dai->dev, "%s: no hext_stream found\n", __func__);
 389                 return -ENODEV;
 390         }
 391
 392         hstream = &hext_stream->hstream;
 393         stream_id = hstream->stream_tag;
 394
 395         if (!stream_id) {
 396                 dev_err(cpu_dai->dev, "%s: no stream_id allocated\n", __func__);
 397                 return -ENODEV;
 398         }
 399
 400         /* configure TLV */
 401         ipc4_copier = widget_to_copier(w);
 402
 403         for_each_rtd_cpu_dais(rtd, cpu_dai_id, dai) {
 404                 if (dai == cpu_dai)
 405                         break;
 406         }
 407
 408         dma_config_tlv = &ipc4_copier->dma_config_tlv[cpu_dai_id];
 409         dma_config_tlv->type = SOF_IPC4_GTW_DMA_CONFIG_ID;
 410         /* dma_config_priv_size is zero */
 411         dma_config_tlv->length = sizeof(dma_config_tlv->dma_config);
 412
 413         dma_config = &dma_config_tlv->dma_config;
 414
 415         dma_config->dma_method = SOF_IPC4_DMA_METHOD_HDA;
 416         dma_config->pre_allocated_by_host = 1;
 417         dma_config->dma_channel_id = stream_id - 1;
 418         dma_config->stream_id = stream_id;
 419         /*
 420          * Currently we use a DMA for each device in ALH blob. The device will
 421          * be copied in sof_ipc4_prepare_copier_module.
 422          */
 423         dma_config->dma_stream_channel_map.device_count = 1;
 424         dma_config->dma_priv_config_size = 0;
 425
 426         return 0;
 427 }
 428
 429 static int non_hda_dai_hw_params(struct snd_pcm_substream *substream,
 430                                  struct snd_pcm_hw_params *params,
 431                                  struct snd_soc_dai *cpu_dai)
 432 {
 433         struct snd_sof_dai_config_data data = { 0 };
 434         unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_PARAMS;
 435
 436         return non_hda_dai_hw_params_data(substream, params, cpu_dai, &data, flags);
 437 }
 438
 439 static int non_hda_dai_prepare(struct snd_pcm_substream *substream,
 440                                struct snd_soc_dai *cpu_dai)
 441 {
 442         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 443         int stream = substream->stream;
 444
 445         return non_hda_dai_hw_params(substream, &rtd->dpcm[stream].hw_params, cpu_dai);
 446 }
 447
 448 static const struct snd_soc_dai_ops ssp_dai_ops = {
 449         .hw_params = non_hda_dai_hw_params,
 450         .hw_free = hda_dai_hw_free,
 451         .trigger = hda_dai_trigger,
 452         .prepare = non_hda_dai_prepare,
 453 };
 454
 455 static const struct snd_soc_dai_ops dmic_dai_ops = {
 456         .hw_params = non_hda_dai_hw_params,
 457         .hw_free = hda_dai_hw_free,
 458         .trigger = hda_dai_trigger,
 459         .prepare = non_hda_dai_prepare,
 460 };
 461
 462 int sdw_hda_dai_hw_params(struct snd_pcm_substream *substream,
 463                           struct snd_pcm_hw_params *params,
 464                           struct snd_soc_dai *cpu_dai,
 465                           int link_id,
 466                           int intel_alh_id)
 467 {
 468         struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
 469         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 470         struct sof_ipc4_dma_config_tlv *dma_config_tlv;
 471         struct snd_sof_dai_config_data data = { 0 };
 472         unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_PARAMS;
 473         const struct hda_dai_widget_dma_ops *ops;
 474         struct sof_ipc4_dma_config *dma_config;
 475         struct sof_ipc4_copier *ipc4_copier;
 476         struct hdac_ext_stream *hext_stream;
 477         struct snd_soc_dai *dai;
 478         struct snd_sof_dev *sdev;
 479         bool cpu_dai_found = false;
 480         int cpu_dai_id;
 481         int ch_mask;
 482         int ret;
 483         int i;
 484
 485         data.dai_index = (link_id << 8) | cpu_dai->id;
 486         data.dai_node_id = intel_alh_id;
 487         ret = non_hda_dai_hw_params_data(substream, params, cpu_dai, &data, flags);
 488         if (ret < 0) {
 489                 dev_err(cpu_dai->dev, "%s: non_hda_dai_hw_params failed %d\n", __func__, ret);
 490                 return ret;
 491         }
 492
 493         ops = hda_dai_get_ops(substream, cpu_dai);
 494         sdev = widget_to_sdev(w);
 495         hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
 496
 497         if (!hext_stream)
 498                 return -ENODEV;
 499
 500         /*
 501          * in the case of SoundWire we need to program the PCMSyCM registers. In case
 502          * of aggregated devices, we need to define the channel mask for each sublink
 503          * by reconstructing the split done in soc-pcm.c
 504          */
 505         for_each_rtd_cpu_dais(rtd, cpu_dai_id, dai) {
 506                 if (dai == cpu_dai) {
 507                         cpu_dai_found = true;
 508                         break;
 509                 }
 510         }
 511
 512         if (!cpu_dai_found)
 513                 return -ENODEV;
 514
 515         ch_mask = GENMASK(params_channels(params) - 1, 0);
 516
 517         ret = hdac_bus_eml_sdw_map_stream_ch(sof_to_bus(sdev), link_id, cpu_dai->id,
 518                                              ch_mask,
 519                                              hdac_stream(hext_stream)->stream_tag,
 520                                              substream->stream);
 521         if (ret < 0) {
 522                 dev_err(cpu_dai->dev, "%s:  hdac_bus_eml_sdw_map_stream_ch failed %d\n",
 523                         __func__, ret);
 524                 return ret;
 525         }
 526
 527         if (sdev->dspless_mode_selected)
 528                 return 0;
 529
 530         ipc4_copier = widget_to_copier(w);
 531         dma_config_tlv = &ipc4_copier->dma_config_tlv[cpu_dai_id];
 532         dma_config = &dma_config_tlv->dma_config;
 533         dma_config->dma_stream_channel_map.mapping[0].device = data.dai_index;
 534         dma_config->dma_stream_channel_map.mapping[0].channel_mask = ch_mask;
 535
 536         /*
 537          * copy the dma_config_tlv to all ipc4_copier in the same link. Because only one copier
 538          * will be handled in sof_ipc4_prepare_copier_module.
 539          */
 540         for_each_rtd_cpu_dais(rtd, i, dai) {
 541                 w = snd_soc_dai_get_widget(dai, substream->stream);
 542                 ipc4_copier = widget_to_copier(w);
 543                 memcpy(&ipc4_copier->dma_config_tlv[cpu_dai_id], dma_config_tlv,
 544                        sizeof(*dma_config_tlv));
 545         }
 546         return 0;
 547 }
 548 EXPORT_SYMBOL_NS(sdw_hda_dai_hw_params, SND_SOC_SOF_INTEL_HDA_COMMON);
 549
 550 int sdw_hda_dai_hw_free(struct snd_pcm_substream *substream,
 551                         struct snd_soc_dai *cpu_dai,
 552                         int link_id)
 553 {
 554         struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
 555         struct snd_sof_dev *sdev;
 556         int ret;
 557
 558         ret = hda_dai_hw_free(substream, cpu_dai);
 559         if (ret < 0) {
 560                 dev_err(cpu_dai->dev, "%s: non_hda_dai_hw_free failed %d\n", __func__, ret);
 561                 return ret;
 562         }
 563
 564         sdev = widget_to_sdev(w);
 565
 566         /* in the case of SoundWire we need to reset the PCMSyCM registers */
 567         ret = hdac_bus_eml_sdw_map_stream_ch(sof_to_bus(sdev), link_id, cpu_dai->id,
 568                                              0, 0, substream->stream);
 569         if (ret < 0) {
 570                 dev_err(cpu_dai->dev, "%s:  hdac_bus_eml_sdw_map_stream_ch failed %d\n",
 571                         __func__, ret);
 572                 return ret;
 573         }
 574
 575         return 0;
 576 }
 577 EXPORT_SYMBOL_NS(sdw_hda_dai_hw_free, SND_SOC_SOF_INTEL_HDA_COMMON);
 578
 579 int sdw_hda_dai_trigger(struct snd_pcm_substream *substream, int cmd,
 580                         struct snd_soc_dai *cpu_dai)
 581 {
 582         return hda_dai_trigger(substream, cmd, cpu_dai);
 583 }
 584 EXPORT_SYMBOL_NS(sdw_hda_dai_trigger, SND_SOC_SOF_INTEL_HDA_COMMON);
 585
 586 static int hda_dai_suspend(struct hdac_bus *bus)
 587 {
 588         struct snd_soc_pcm_runtime *rtd;
 589         struct hdac_ext_stream *hext_stream;
 590         struct hdac_stream *s;
 591         int ret;
 592
 593         /* set internal flag for BE */
 594         list_for_each_entry(s, &bus->stream_list, list) {
 595
 596                 hext_stream = stream_to_hdac_ext_stream(s);
 597
 598                 /*
 599                  * clear stream. This should already be taken care for running
 600                  * streams when the SUSPEND trigger is called. But paused
 601                  * streams do not get suspended, so this needs to be done
 602                  * explicitly during suspend.
 603                  */
 604                 if (hext_stream->link_substream) {
 605                         const struct hda_dai_widget_dma_ops *ops;
 606                         struct snd_sof_widget *swidget;
 607                         struct snd_soc_dapm_widget *w;
 608                         struct snd_soc_dai *cpu_dai;
 609                         struct snd_sof_dev *sdev;
 610                         struct snd_sof_dai *sdai;
 611
 612                         rtd = snd_soc_substream_to_rtd(hext_stream->link_substream);
 613                         cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
 614                         w = snd_soc_dai_get_widget(cpu_dai, hdac_stream(hext_stream)->direction);
 615                         swidget = w->dobj.private;
 616                         sdev = widget_to_sdev(w);
 617                         sdai = swidget->private;
 618                         ops = sdai->platform_private;
 619
 620                         /* for consistency with TRIGGER_SUSPEND  */
 621                         if (ops->post_trigger) {
 622                                 ret = ops->post_trigger(sdev, cpu_dai,
 623                                                         hext_stream->link_substream,
 624                                                         SNDRV_PCM_TRIGGER_SUSPEND);
 625                                 if (ret < 0)
 626                                         return ret;
 627                         }
 628
 629                         ret = hda_link_dma_cleanup(hext_stream->link_substream,
 630                                                    hext_stream,
 631                                                    cpu_dai);
 632                         if (ret < 0)
 633                                 return ret;
 634                 }
 635         }
 636
 637         return 0;
 638 }
 639
 640 static void ssp_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops)
 641 {
 642         const struct sof_intel_dsp_desc *chip;
 643         int i;
 644
 645         chip = get_chip_info(sdev->pdata);
 646
 647         if (chip->hw_ip_version >= SOF_INTEL_ACE_2_0) {
 648                 for (i = 0; i < ops->num_drv; i++) {
 649                         if (strstr(ops->drv[i].name, "SSP"))
 650                                 ops->drv[i].ops = &ssp_dai_ops;
 651                 }
 652         }
 653 }
 654
 655 static void dmic_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops)
 656 {
 657         const struct sof_intel_dsp_desc *chip;
 658         int i;
 659
 660         chip = get_chip_info(sdev->pdata);
 661
 662         if (chip->hw_ip_version >= SOF_INTEL_ACE_2_0) {
 663                 for (i = 0; i < ops->num_drv; i++) {
 664                         if (strstr(ops->drv[i].name, "DMIC"))
 665                                 ops->drv[i].ops = &dmic_dai_ops;
 666                 }
 667         }
 668 }
 669
 670 #else
 671
 672 static inline void ssp_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops) {}
 673 static inline void dmic_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops) {}
 674
 675 #endif /* CONFIG_SND_SOC_SOF_HDA_LINK */
 676
 677 void hda_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops)
 678 {
 679         int i;
 680
 681         for (i = 0; i < ops->num_drv; i++) {
 682 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
 683                 if (strstr(ops->drv[i].name, "iDisp") ||
 684                     strstr(ops->drv[i].name, "Analog") ||
 685                     strstr(ops->drv[i].name, "Digital"))
 686                         ops->drv[i].ops = &hda_dai_ops;
 687 #endif
 688         }
 689
 690         ssp_set_dai_drv_ops(sdev, ops);
 691         dmic_set_dai_drv_ops(sdev, ops);
 692
 693         if (sdev->pdata->ipc_type == SOF_IPC_TYPE_4 && !hda_use_tplg_nhlt) {
 694                 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 695
 696                 ipc4_data->nhlt = intel_nhlt_init(sdev->dev);
 697         }
 698 }
 699 EXPORT_SYMBOL_NS(hda_set_dai_drv_ops, SND_SOC_SOF_INTEL_HDA_COMMON);
 700
 701 void hda_ops_free(struct snd_sof_dev *sdev)
 702 {
 703         if (sdev->pdata->ipc_type == SOF_IPC_TYPE_4) {
 704                 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 705
 706                 if (!hda_use_tplg_nhlt)
 707                         intel_nhlt_free(ipc4_data->nhlt);
 708
 709                 kfree(sdev->private);
 710                 sdev->private = NULL;
 711         }
 712 }
 713 EXPORT_SYMBOL_NS(hda_ops_free, SND_SOC_SOF_INTEL_HDA_COMMON);
 714
 715 /*
 716  * common dai driver for skl+ platforms.
 717  * some products who use this DAI array only physically have a subset of
 718  * the DAIs, but no harm is done here by adding the whole set.
 719  */
 720 struct snd_soc_dai_driver skl_dai[] = {
 721 {
 722         .name = "SSP0 Pin",
 723         .playback = {
 724                 .channels_min = 1,
 725                 .channels_max = 8,
 726         },
 727         .capture = {
 728                 .channels_min = 1,
 729                 .channels_max = 8,
 730         },
 731 },
 732 {
 733         .name = "SSP1 Pin",
 734         .playback = {
 735                 .channels_min = 1,
 736                 .channels_max = 8,
 737         },
 738         .capture = {
 739                 .channels_min = 1,
 740                 .channels_max = 8,
 741         },
 742 },
 743 {
 744         .name = "SSP2 Pin",
 745         .playback = {
 746                 .channels_min = 1,
 747                 .channels_max = 8,
 748         },
 749         .capture = {
 750                 .channels_min = 1,
 751                 .channels_max = 8,
 752         },
 753 },
 754 {
 755         .name = "SSP3 Pin",
 756         .playback = {
 757                 .channels_min = 1,
 758                 .channels_max = 8,
 759         },
 760         .capture = {
 761                 .channels_min = 1,
 762                 .channels_max = 8,
 763         },
 764 },
 765 {
 766         .name = "SSP4 Pin",
 767         .playback = {
 768                 .channels_min = 1,
 769                 .channels_max = 8,
 770         },
 771         .capture = {
 772                 .channels_min = 1,
 773                 .channels_max = 8,
 774         },
 775 },
 776 {
 777         .name = "SSP5 Pin",
 778         .playback = {
 779                 .channels_min = 1,
 780                 .channels_max = 8,
 781         },
 782         .capture = {
 783                 .channels_min = 1,
 784                 .channels_max = 8,
 785         },
 786 },
 787 {
 788         .name = "DMIC01 Pin",
 789         .capture = {
 790                 .channels_min = 1,
 791                 .channels_max = 4,
 792         },
 793 },
 794 {
 795         .name = "DMIC16k Pin",
 796         .capture = {
 797                 .channels_min = 1,
 798                 .channels_max = 4,
 799         },
 800 },
 801 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
 802 {
 803         .name = "iDisp1 Pin",
 804         .playback = {
 805                 .channels_min = 1,
 806                 .channels_max = 8,
 807         },
 808 },
 809 {
 810         .name = "iDisp2 Pin",
 811         .playback = {
 812                 .channels_min = 1,
 813                 .channels_max = 8,
 814         },
 815 },
 816 {
 817         .name = "iDisp3 Pin",
 818         .playback = {
 819                 .channels_min = 1,
 820                 .channels_max = 8,
 821         },
 822 },
 823 {
 824         .name = "iDisp4 Pin",
 825         .playback = {
 826                 .channels_min = 1,
 827                 .channels_max = 8,
 828         },
 829 },
 830 {
 831         .name = "Analog CPU DAI",
 832         .playback = {
 833                 .channels_min = 1,
 834                 .channels_max = 16,
 835         },
 836         .capture = {
 837                 .channels_min = 1,
 838                 .channels_max = 16,
 839         },
 840 },
 841 {
 842         .name = "Digital CPU DAI",
 843         .playback = {
 844                 .channels_min = 1,
 845                 .channels_max = 16,
 846         },
 847         .capture = {
 848                 .channels_min = 1,
 849                 .channels_max = 16,
 850         },
 851 },
 852 {
 853         .name = "Alt Analog CPU DAI",
 854         .playback = {
 855                 .channels_min = 1,
 856                 .channels_max = 16,
 857         },
 858         .capture = {
 859                 .channels_min = 1,
 860                 .channels_max = 16,
 861         },
 862 },
 863 #endif
 864 };
 865 EXPORT_SYMBOL_NS(skl_dai, SND_SOC_SOF_INTEL_HDA_COMMON);
 866
 867 int hda_dsp_dais_suspend(struct snd_sof_dev *sdev)
 868 {
 869         /*
 870          * In the corner case where a SUSPEND happens during a PAUSE, the ALSA core
 871          * does not throw the TRIGGER_SUSPEND. This leaves the DAIs in an unbalanced state.
 872          * Since the component suspend is called last, we can trap this corner case
 873          * and force the DAIs to release their resources.
 874          */
 875 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_LINK)
 876         int ret;
 877
 878         ret = hda_dai_suspend(sof_to_bus(sdev));
 879         if (ret < 0)
 880                 return ret;
 881 #endif
 882
 883         return 0;
 884 }