On 4/27/22 03:18, Cezary Rojewski wrote:
> Add generic ASoC equivalent of ALSA HD-Audio codec. This codec is
> designed to follow HDA_DEV_LEGACY convention. Driver wrapps existing
> hda_codec.c handlers to prevent code duplication within the newly added
> code. Number of DAIs created is dependent on capabilities exposed by the
> codec itself. Because of this, single solution can be applied to support
> every single HD-Audio codec type.
>
> At the same, through the ASoC topology, platform drivers may limit the
> number of endpoints available to the userspace as codec driver exposes
> BE DAIs only.
>
> Both hda_codec_probe() and hda_codec_remove() declare their expectations
> on device's usage_count and suspended-status. This is to catch any
> unexpected behavior as PM-related code for HD-Audio has been changing
> quite a bit throughout the years.
>
> In order for codec DAI list to reflect its actual PCM capabilities, PCMs
> need to be built and that can only happen once codec device is
> constructed. To do that, a valid component->card->snd_card pointer is
> needed. Said pointer will be provided by the framework once all card
> components are accounted for and their probing can begin. Usage of
> "binder" BE DAI solves the problem - codec can be listed as one of
> HD-Audio card components without declaring any actual BE DAIs
> statically.
I am surprised the explanations don't even mention the existence of hdac_hda.c
/*
* hdac_hda.c - ASoC extensions to reuse the legacy HDA codec drivers
* with ASoC platform drivers. These APIs are called by the legacy HDA
* codec drivers using hdac_ext_bus_ops ops.
*/
I thought the series was about adding machine drivers, but this also adds code on the sound/soc/codecs/ side which I didn't see coming.
I am not qualified to review this part of the code, I just wonder about duplication of functionality.
At the very least an explanation on why you decided to NOT use hdac_hda.c would be useful to reviewers and maintainers.
Thanks.
>
> Signed-off-by: Cezary Rojewski <cezary.rojewski@xxxxxxxxx>
> ---
> sound/soc/codecs/Kconfig | 5 +
> sound/soc/codecs/Makefile | 2 +
> sound/soc/codecs/hda-dai.c | 102 ++++++++++
> sound/soc/codecs/hda.c | 395 +++++++++++++++++++++++++++++++++++++
> sound/soc/codecs/hda.h | 19 ++
> 5 files changed, 523 insertions(+)
> create mode 100644 sound/soc/codecs/hda-dai.c
> create mode 100644 sound/soc/codecs/hda.c
> create mode 100644 sound/soc/codecs/hda.h
>
> diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
> index b106e5517090..23fdbf97e453 100644
> --- a/sound/soc/codecs/Kconfig
> +++ b/sound/soc/codecs/Kconfig
> @@ -937,6 +937,11 @@ config SND_SOC_HDAC_HDA
> tristate
> select SND_HDA
>
> +config SND_SOC_HDA
> + tristate "HD-Audio codec driver"
> + select SND_HDA_EXT_CORE
> + select SND_HDA
> +
> config SND_SOC_ICS43432
> tristate "ICS43423 and compatible i2s microphones"
>
> diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
> index 28dc4edfd01f..d32026ae326f 100644
> --- a/sound/soc/codecs/Makefile
> +++ b/sound/soc/codecs/Makefile
> @@ -106,6 +106,7 @@ snd-soc-es8328-spi-objs := es8328-spi.o
> snd-soc-gtm601-objs := gtm601.o
> snd-soc-hdac-hdmi-objs := hdac_hdmi.o
> snd-soc-hdac-hda-objs := hdac_hda.o
> +snd-soc-hda-codec-objs := hda.o hda-dai.o
> snd-soc-ics43432-objs := ics43432.o
> snd-soc-inno-rk3036-objs := inno_rk3036.o
> snd-soc-isabelle-objs := isabelle.o
> @@ -458,6 +459,7 @@ obj-$(CONFIG_SND_SOC_ES8328_SPI)+= snd-soc-es8328-spi.o
> obj-$(CONFIG_SND_SOC_GTM601) += snd-soc-gtm601.o
> obj-$(CONFIG_SND_SOC_HDAC_HDMI) += snd-soc-hdac-hdmi.o
> obj-$(CONFIG_SND_SOC_HDAC_HDA) += snd-soc-hdac-hda.o
> +obj-$(CONFIG_SND_SOC_HDA) += snd-soc-hda-codec.o
> obj-$(CONFIG_SND_SOC_ICS43432) += snd-soc-ics43432.o
> obj-$(CONFIG_SND_SOC_INNO_RK3036) += snd-soc-inno-rk3036.o
> obj-$(CONFIG_SND_SOC_ISABELLE) += snd-soc-isabelle.o
> diff --git a/sound/soc/codecs/hda-dai.c b/sound/soc/codecs/hda-dai.c
> new file mode 100644
> index 000000000000..5371ff086261
> --- /dev/null
> +++ b/sound/soc/codecs/hda-dai.c
> @@ -0,0 +1,102 @@
> +// SPDX-License-Identifier: GPL-2.0
> +//
> +// Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
> +//
> +// Author: Cezary Rojewski <cezary.rojewski@xxxxxxxxx>
> +//
> +
> +#include <sound/soc.h>
> +#include <sound/hda_codec.h>
> +#include "hda.h"
> +
> +static int hda_codec_dai_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
> +{
> + struct hda_pcm_stream *stream_info;
> + struct hda_codec *codec;
> + struct hda_pcm *pcm;
> + int ret;
> +
> + codec = dev_to_hda_codec(dai->dev);
> + stream_info = snd_soc_dai_get_dma_data(dai, substream);
> + pcm = container_of(stream_info, struct hda_pcm, stream[substream->stream]);
> +
> + dev_dbg(dai->dev, "open stream codec: %08x, info: %p, pcm: %p %s substream: %p\n",
> + codec->core.vendor_id, stream_info, pcm, pcm->name, substream);
> +
> + snd_hda_codec_pcm_get(pcm);
> +
> + ret = stream_info->ops.open(stream_info, codec, substream);
> + if (ret < 0) {
> + dev_err(dai->dev, "codec open failed: %d\n", ret);
> + snd_hda_codec_pcm_put(pcm);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static void hda_codec_dai_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
> +{
> + struct hda_pcm_stream *stream_info;
> + struct hda_codec *codec;
> + struct hda_pcm *pcm;
> + int ret;
> +
> + codec = dev_to_hda_codec(dai->dev);
> + stream_info = snd_soc_dai_get_dma_data(dai, substream);
> + pcm = container_of(stream_info, struct hda_pcm, stream[substream->stream]);
> +
> + dev_dbg(dai->dev, "close stream codec: %08x, info: %p, pcm: %p %s substream: %p\n",
> + codec->core.vendor_id, stream_info, pcm, pcm->name, substream);
> +
> + ret = stream_info->ops.close(stream_info, codec, substream);
> + if (ret < 0)
> + dev_err(dai->dev, "codec close failed: %d\n", ret);
> +
> + snd_hda_codec_pcm_put(pcm);
> +}
> +
> +static int hda_codec_dai_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
> +{
> + struct hda_pcm_stream *stream_info;
> + struct hda_codec *codec;
> +
> + codec = dev_to_hda_codec(dai->dev);
> + stream_info = snd_soc_dai_get_dma_data(dai, substream);
> +
> + snd_hda_codec_cleanup(codec, stream_info, substream);
> +
> + return 0;
> +}
> +
> +static int hda_codec_dai_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
> +{
> + struct snd_pcm_runtime *runtime = substream->runtime;
> + struct hda_pcm_stream *stream_info;
> + struct hdac_stream *stream;
> + struct hda_codec *codec;
> + unsigned int format;
> + int ret;
> +
> + codec = dev_to_hda_codec(dai->dev);
> + stream = substream->runtime->private_data;
> + stream_info = snd_soc_dai_get_dma_data(dai, substream);
> + format = snd_hdac_calc_stream_format(runtime->rate, runtime->channels, runtime->format,
> + runtime->sample_bits, 0);
> +
> + ret = snd_hda_codec_prepare(codec, stream_info, stream->stream_tag, format, substream);
> + if (ret < 0) {
> + dev_err(dai->dev, "codec prepare failed: %d\n", ret);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +const struct snd_soc_dai_ops snd_soc_hda_codec_dai_ops = {
> + .startup = hda_codec_dai_startup,
> + .shutdown = hda_codec_dai_shutdown,
> + .hw_free = hda_codec_dai_hw_free,
> + .prepare = hda_codec_dai_prepare,
> +};
> +EXPORT_SYMBOL_GPL(snd_soc_hda_codec_dai_ops);
> diff --git a/sound/soc/codecs/hda.c b/sound/soc/codecs/hda.c
> new file mode 100644
> index 000000000000..edcb8bc6806b
> --- /dev/null
> +++ b/sound/soc/codecs/hda.c
> @@ -0,0 +1,395 @@
> +// SPDX-License-Identifier: GPL-2.0
> +//
> +// Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
> +//
> +// Author: Cezary Rojewski <cezary.rojewski@xxxxxxxxx>
> +//
> +
> +#include <linux/module.h>
> +#include <linux/pm_runtime.h>
> +#include <sound/soc.h>
> +#include <sound/hdaudio_ext.h>
> +#include <sound/hda_i915.h>
> +#include <sound/hda_codec.h>
> +#include "hda.h"
> +
> +static int hda_codec_create_dais(struct hda_codec *codec, int pcm_count,
> + struct snd_soc_dai_driver **drivers)
> +{
> + struct device *dev = &codec->core.dev;
> + struct snd_soc_dai_driver *drvs;
> + struct hda_pcm *pcm;
> + int i;
> +
> + drvs = devm_kcalloc(dev, pcm_count, sizeof(*drvs), GFP_KERNEL);
> + if (!drvs)
> + return -ENOMEM;
> +
> + pcm = list_first_entry(&codec->pcm_list_head, struct hda_pcm, list);
> +
> + for (i = 0; i < pcm_count; i++, pcm = list_next_entry(pcm, list)) {
> + struct snd_soc_pcm_stream *stream;
> + int dir;
> +
> + dev_info(dev, "creating for %s %d\n", pcm->name, i);
> + drvs[i].id = i;
> + drvs[i].name = pcm->name;
> + drvs[i].ops = &snd_soc_hda_codec_dai_ops;
> +
> + dir = SNDRV_PCM_STREAM_PLAYBACK;
> + stream = &drvs[i].playback;
> + if (!pcm->stream[dir].substreams) {
> + dev_info(dev, "skipping playback dai for %s\n", pcm->name);
> + goto capture_dais;
> + }
> +
> + stream->stream_name =
> + devm_kasprintf(dev, GFP_KERNEL, "%s %s", pcm->name,
> + snd_pcm_direction_name(dir));
> + if (!stream->stream_name)
> + return -ENOMEM;
> + stream->channels_min = pcm->stream[dir].channels_min;
> + stream->channels_max = pcm->stream[dir].channels_max;
> + stream->rates = pcm->stream[dir].rates;
> + stream->formats = pcm->stream[dir].formats;
> + stream->sig_bits = pcm->stream[dir].maxbps;
> +
> +capture_dais:
> + dir = SNDRV_PCM_STREAM_CAPTURE;
> + stream = &drvs[i].capture;
> + if (!pcm->stream[dir].substreams) {
> + dev_info(dev, "skipping capture dai for %s\n", pcm->name);
> + continue;
> + }
> +
> + stream->stream_name =
> + devm_kasprintf(dev, GFP_KERNEL, "%s %s", pcm->name,
> + snd_pcm_direction_name(dir));
> + if (!stream->stream_name)
> + return -ENOMEM;
> + stream->channels_min = pcm->stream[dir].channels_min;
> + stream->channels_max = pcm->stream[dir].channels_max;
> + stream->rates = pcm->stream[dir].rates;
> + stream->formats = pcm->stream[dir].formats;
> + stream->sig_bits = pcm->stream[dir].maxbps;
> + }
> +
> + *drivers = drvs;
> + return 0;
> +}
> +
> +static int hda_codec_register_dais(struct hda_codec *codec, struct snd_soc_component *component)
> +{
> + struct snd_soc_dai_driver *drvs = NULL;
> + struct snd_soc_dapm_context *dapm;
> + struct hda_pcm *pcm;
> + int ret, pcm_count = 0;
> +
> + if (list_empty(&codec->pcm_list_head))
> + return -EINVAL;
> + list_for_each_entry(pcm, &codec->pcm_list_head, list)
> + pcm_count++;
> +
> + ret = hda_codec_create_dais(codec, pcm_count, &drvs);
> + if (ret < 0)
> + return ret;
> +
> + dapm = snd_soc_component_get_dapm(component);
> +
> + list_for_each_entry(pcm, &codec->pcm_list_head, list) {
> + struct snd_soc_dai *dai;
> +
> + dai = snd_soc_register_dai(component, drvs, false);
> + if (!dai) {
> + dev_err(component->dev, "register dai for %s failed\n", pcm->name);
> + return -EINVAL;
> + }
> +
> + ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
> + if (ret < 0) {
> + dev_err(component->dev, "create widgets failed: %d\n", ret);
> + snd_soc_unregister_dai(dai);
> + return ret;
> + }
> +
> + snd_soc_dai_init_dma_data(dai, &pcm->stream[0], &pcm->stream[1]);
> + drvs++;
> + }
> +
> + return 0;
> +}
> +
> +static void hda_codec_unregister_dais(struct hda_codec *codec,
> + struct snd_soc_component *component)
> +{
> + struct snd_soc_dai *dai, *save;
> + struct hda_pcm *pcm;
> +
> + for_each_component_dais_safe(component, dai, save) {
> + list_for_each_entry(pcm, &codec->pcm_list_head, list) {
> + if (strcmp(dai->driver->name, pcm->name))
> + continue;
> +
> + if (dai->playback_widget)
> + snd_soc_dapm_free_widget(dai->playback_widget);
> + if (dai->capture_widget)
> + snd_soc_dapm_free_widget(dai->capture_widget);
> + snd_soc_unregister_dai(dai);
> + break;
> + }
> + }
> +}
> +
> +int hda_codec_probe_complete(struct hda_codec *codec)
> +{
> + struct hdac_device *hdev = &codec->core;
> + struct hdac_bus *bus = hdev->bus;
> + int ret;
> +
> + ret = snd_hda_codec_build_controls(codec);
> + if (ret < 0) {
> + dev_err(&hdev->dev, "unable to create controls %d\n", ret);
> + goto out;
> + }
> +
> + /* Bus suspended codecs as it does not manage their pm */
> + pm_runtime_set_active(&hdev->dev);
> + /* rpm was forbidden in snd_hda_codec_device_new() */
> + snd_hda_codec_set_power_save(codec, 2000);
> + snd_hda_codec_register(codec);
> +out:
> + /* Complement pm_runtime_get_sync(bus) in probe */
> + pm_runtime_mark_last_busy(bus->dev);
> + pm_runtime_put_autosuspend(bus->dev);
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(hda_codec_probe_complete);
> +
> +/* Expects codec with usage_count=1 and status=suspended */
> +static int hda_codec_probe(struct snd_soc_component *component)
> +{
> + struct hda_codec *codec = dev_to_hda_codec(component->dev);
> + struct hdac_device *hdev = &codec->core;
> + struct hdac_bus *bus = hdev->bus;
> + struct hdac_ext_link *hlink;
> + hda_codec_patch_t patch;
> + int ret;
> +
> +#ifdef CONFIG_PM
> + WARN_ON(atomic_read(&hdev->dev.power.usage_count) != 1 ||
> + !pm_runtime_status_suspended(&hdev->dev));
> +#endif
> +
> + hlink = snd_hdac_ext_bus_link_at(bus, hdev->addr);
> + if (!hlink) {
> + dev_err(&hdev->dev, "hdac link not found\n");
> + return -EIO;
> + }
> +
> + pm_runtime_get_sync(bus->dev);
> + if (hda_codec_is_display(codec))
> + snd_hdac_display_power(bus, hdev->addr, true);
> + snd_hdac_ext_bus_link_get(bus, hlink);
> +
> + ret = snd_hda_codec_device_new(codec->bus, component->card->snd_card, hdev->addr, codec,
> + false);
> + if (ret < 0) {
> + dev_err(&hdev->dev, "create hda codec failed: %d\n", ret);
> + goto device_new_err;
> + }
> +
> + ret = snd_hda_codec_set_name(codec, codec->preset->name);
> + if (ret < 0) {
> + dev_err(&hdev->dev, "name failed %s\n", codec->preset->name);
> + goto err;
> + }
> +
> + ret = snd_hdac_regmap_init(&codec->core);
> + if (ret < 0) {
> + dev_err(&hdev->dev, "regmap init failed\n");
> + goto err;
> + }
> +
> + patch = (hda_codec_patch_t)codec->preset->driver_data;
> + if (!patch) {
> + dev_err(&hdev->dev, "no patch specified?\n");
> + ret = -EINVAL;
> + goto err;
> + }
> +
> + ret = patch(codec);
> + if (ret < 0) {
> + dev_err(&hdev->dev, "patch failed %d\n", ret);
> + goto err;
> + }
> +
> + /* configure codec for 1:1 PCM:DAI mapping */
> + codec->mst_no_extra_pcms = 1;
> +
> + ret = snd_hda_codec_parse_pcms(codec);
> + if (ret < 0) {
> + dev_err(&hdev->dev, "unable to map pcms to dai %d\n", ret);
> + goto parse_pcms_err;
> + }
> +
> + ret = hda_codec_register_dais(codec, component);
> + if (ret < 0) {
> + dev_err(&hdev->dev, "update dais failed: %d\n", ret);
> + goto parse_pcms_err;
> + }
> +
> + if (!hda_codec_is_display(codec)) {
> + ret = hda_codec_probe_complete(codec);
> + if (ret < 0)
> + goto complete_err;
> + }
> +
> + codec->core.lazy_cache = true;
> +
> + return 0;
> +
> +complete_err:
> + hda_codec_unregister_dais(codec, component);
> +parse_pcms_err:
> + if (codec->patch_ops.free)
> + codec->patch_ops.free(codec);
> +err:
> + snd_hda_codec_cleanup_for_unbind(codec);
> +device_new_err:
> + if (hda_codec_is_display(codec))
> + snd_hdac_display_power(bus, hdev->addr, false);
> +
> + snd_hdac_ext_bus_link_put(bus, hlink);
> +
> + pm_runtime_mark_last_busy(bus->dev);
> + pm_runtime_put_autosuspend(bus->dev);
> + return ret;
> +}
> +
> +/* Leaves codec with usage_count=1 and status=suspended */
> +static void hda_codec_remove(struct snd_soc_component *component)
> +{
> + struct hda_codec *codec = dev_to_hda_codec(component->dev);
> + struct hdac_device *hdev = &codec->core;
> + struct hdac_bus *bus = hdev->bus;
> + struct hdac_ext_link *hlink;
> + bool was_registered = codec->registered;
> +
> + /* Don't allow any more runtime suspends */
> + pm_runtime_forbid(&hdev->dev);
> +
> + hda_codec_unregister_dais(codec, component);
> +
> + if (codec->patch_ops.free)
> + codec->patch_ops.free(codec);
> +
> + snd_hda_codec_cleanup_for_unbind(codec);
> + pm_runtime_put_noidle(&hdev->dev);
> + /* snd_hdac_device_exit() is only called on bus remove */
> + pm_runtime_set_suspended(&hdev->dev);
> +
> + if (hda_codec_is_display(codec))
> + snd_hdac_display_power(bus, hdev->addr, false);
> +
> + hlink = snd_hdac_ext_bus_link_at(bus, hdev->addr);
> + if (hlink)
> + snd_hdac_ext_bus_link_put(bus, hlink);
> + /*
> + * HDMI card's hda_codec_probe_complete() (see late_probe()) may
> + * not be called due to early error, leaving bus uc unbalanced
> + */
> + if (!was_registered) {
> + pm_runtime_mark_last_busy(bus->dev);
> + pm_runtime_put_autosuspend(bus->dev);
> + }
> +
> +#ifdef CONFIG_PM
> + WARN_ON(atomic_read(&hdev->dev.power.usage_count) != 1 ||
> + !pm_runtime_status_suspended(&hdev->dev));
> +#endif
> +}
> +
> +static const struct snd_soc_dapm_route hda_dapm_routes[] = {
> + {"AIF1TX", NULL, "Codec Input Pin1"},
> + {"AIF2TX", NULL, "Codec Input Pin2"},
> + {"AIF3TX", NULL, "Codec Input Pin3"},
> +
> + {"Codec Output Pin1", NULL, "AIF1RX"},
> + {"Codec Output Pin2", NULL, "AIF2RX"},
> + {"Codec Output Pin3", NULL, "AIF3RX"},
> +};
> +
> +static const struct snd_soc_dapm_widget hda_dapm_widgets[] = {
> + /* Audio Interface */
> + SND_SOC_DAPM_AIF_IN("AIF1RX", "Analog Codec Playback", 0, SND_SOC_NOPM, 0, 0),
> + SND_SOC_DAPM_AIF_IN("AIF2RX", "Digital Codec Playback", 0, SND_SOC_NOPM, 0, 0),
> + SND_SOC_DAPM_AIF_IN("AIF3RX", "Alt Analog Codec Playback", 0, SND_SOC_NOPM, 0, 0),
> + SND_SOC_DAPM_AIF_OUT("AIF1TX", "Analog Codec Capture", 0, SND_SOC_NOPM, 0, 0),
> + SND_SOC_DAPM_AIF_OUT("AIF2TX", "Digital Codec Capture", 0, SND_SOC_NOPM, 0, 0),
> + SND_SOC_DAPM_AIF_OUT("AIF3TX", "Alt Analog Codec Capture", 0, SND_SOC_NOPM, 0, 0),
> +
> + /* Input Pins */
> + SND_SOC_DAPM_INPUT("Codec Input Pin1"),
> + SND_SOC_DAPM_INPUT("Codec Input Pin2"),
> + SND_SOC_DAPM_INPUT("Codec Input Pin3"),
> +
> + /* Output Pins */
> + SND_SOC_DAPM_OUTPUT("Codec Output Pin1"),
> + SND_SOC_DAPM_OUTPUT("Codec Output Pin2"),
> + SND_SOC_DAPM_OUTPUT("Codec Output Pin3"),
> +};
> +
> +static struct snd_soc_dai_driver card_binder_dai = {
> + .id = -1,
> + .name = "codec-probing-DAI",
> +};
> +
> +static int hda_hdev_attach(struct hdac_device *hdev)
> +{
> + struct hda_codec *codec = dev_to_hda_codec(&hdev->dev);
> + struct snd_soc_component_driver *comp_drv;
> +
> + comp_drv = devm_kzalloc(&hdev->dev, sizeof(*comp_drv), GFP_KERNEL);
> + if (!comp_drv)
> + return -ENOMEM;
> +
> + /*
> + * It's save to rely on dev_name() rather than a copy as component
> + * driver's lifetime is directly tied to hda codec one
> + */
> + comp_drv->name = dev_name(&hdev->dev);
> + comp_drv->probe = hda_codec_probe;
> + comp_drv->remove = hda_codec_remove;
> + comp_drv->idle_bias_on = false;
> + if (!hda_codec_is_display(codec)) {
> + comp_drv->dapm_widgets = hda_dapm_widgets;
> + comp_drv->num_dapm_widgets = ARRAY_SIZE(hda_dapm_widgets);
> + comp_drv->dapm_routes = hda_dapm_routes;
> + comp_drv->num_dapm_routes = ARRAY_SIZE(hda_dapm_routes);
> + }
> +
> + return snd_soc_register_component(&hdev->dev, comp_drv, &card_binder_dai, 1);
> +}
> +
> +static int hda_hdev_detach(struct hdac_device *hdev)
> +{
> + struct hda_codec *codec = dev_to_hda_codec(&hdev->dev);
> +
> + if (codec->registered)
> + cancel_delayed_work_sync(&codec->jackpoll_work);
> +
> + snd_soc_unregister_component(&hdev->dev);
> +
> + return 0;
> +}
> +
> +const struct hdac_ext_bus_ops soc_hda_ext_bus_ops = {
> + .hdev_attach = hda_hdev_attach,
> + .hdev_detach = hda_hdev_detach,
> +};
> +EXPORT_SYMBOL_GPL(soc_hda_ext_bus_ops);
> +
> +MODULE_DESCRIPTION("HD-Audio codec driver");
> +MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@xxxxxxxxx>");
> +MODULE_LICENSE("GPL");
> diff --git a/sound/soc/codecs/hda.h b/sound/soc/codecs/hda.h
> new file mode 100644
> index 000000000000..78a2be4945b1
> --- /dev/null
> +++ b/sound/soc/codecs/hda.h
> @@ -0,0 +1,19 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
> + *
> + * Author: Cezary Rojewski <cezary.rojewski@xxxxxxxxx>
> + */
> +
> +#ifndef SND_SOC_CODECS_HDA_H
> +#define SND_SOC_CODECS_HDA_H
> +
> +#define hda_codec_is_display(codec) \
> + ((((codec)->core.vendor_id >> 16) & 0xFFFF) == 0x8086)
> +
> +extern const struct snd_soc_dai_ops snd_soc_hda_codec_dai_ops;
> +
> +extern const struct hdac_ext_bus_ops soc_hda_ext_bus_ops;
> +int hda_codec_probe_complete(struct hda_codec *codec);
> +
> +#endif
