ASoC: hdac_hda: add asoc extension for legacy HDA codec drivers (6bae5ea9) · Commits · 戴 / test

sound/pci/hda/hda_bind.c

+12 −0

Original line number	Diff line number	Diff line
		@@ -81,6 +81,12 @@ static int hda_codec_driver_probe(struct device *dev)
		hda_codec_patch_t patch;
		int err;

		if (codec->bus->core.ext_ops) {
		if (WARN_ON(!codec->bus->core.ext_ops->hdev_attach))
		return -EINVAL;
		return codec->bus->core.ext_ops->hdev_attach(&codec->core);
		}

		if (WARN_ON(!codec->preset))
		return -EINVAL;

		@@ -134,6 +140,12 @@ static int hda_codec_driver_remove(struct device *dev)
		{
		struct hda_codec *codec = dev_to_hda_codec(dev);

		if (codec->bus->core.ext_ops) {
		if (WARN_ON(!codec->bus->core.ext_ops->hdev_detach))
		return -EINVAL;
		return codec->bus->core.ext_ops->hdev_detach(&codec->core);
		}

		if (codec->patch_ops.free)
		codec->patch_ops.free(codec);
		snd_hda_codec_cleanup_for_unbind(codec);

sound/soc/codecs/Kconfig

+5 −0

Original line number	Diff line number	Diff line
		@@ -82,6 +82,7 @@ config SND_SOC_ALL_CODECS
		select SND_SOC_ES7241
		select SND_SOC_GTM601
		select SND_SOC_HDAC_HDMI
		select SND_SOC_HDAC_HDA
		select SND_SOC_ICS43432
		select SND_SOC_INNO_RK3036
		select SND_SOC_ISABELLE if I2C
		@@ -615,6 +616,10 @@ config SND_SOC_HDAC_HDMI
		select SND_PCM_ELD
		select HDMI

		config SND_SOC_HDAC_HDA
		tristate
		select SND_HDA

		config SND_SOC_ICS43432
		tristate

sound/soc/codecs/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -78,6 +78,7 @@ snd-soc-es8328-i2c-objs := es8328-i2c.o
		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-ics43432-objs := ics43432.o
		snd-soc-inno-rk3036-objs := inno_rk3036.o
		snd-soc-isabelle-objs := isabelle.o
		@@ -338,6 +339,7 @@ obj-$(CONFIG_SND_SOC_ES8328_I2C)+= snd-soc-es8328-i2c.o
		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_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

sound/soc/codecs/hdac_hda.c

0 → 100644

+484 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		// Copyright(c) 2015-18 Intel Corporation.

		/*
		* 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.
		*/

		#include <linux/init.h>
		#include <linux/delay.h>
		#include <linux/module.h>
		#include <linux/pm_runtime.h>
		#include <sound/pcm_params.h>
		#include <sound/soc.h>
		#include <sound/hdaudio_ext.h>
		#include <sound/hda_codec.h>
		#include <sound/hda_register.h>
		#include "hdac_hda.h"

		#define HDAC_ANALOG_DAI_ID 0
		#define HDAC_DIGITAL_DAI_ID 1
		#define HDAC_ALT_ANALOG_DAI_ID 2

		#define STUB_FORMATS (SNDRV_PCM_FMTBIT_S8 \| \
		SNDRV_PCM_FMTBIT_U8 \| \
		SNDRV_PCM_FMTBIT_S16_LE \| \
		SNDRV_PCM_FMTBIT_U16_LE \| \
		SNDRV_PCM_FMTBIT_S24_LE \| \
		SNDRV_PCM_FMTBIT_U24_LE \| \
		SNDRV_PCM_FMTBIT_S32_LE \| \
		SNDRV_PCM_FMTBIT_U32_LE \| \
		SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)

		static int hdac_hda_dai_open(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai);
		static void hdac_hda_dai_close(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai);
		static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai);
		static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai);
		static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai,
		unsigned int tx_mask, unsigned int rx_mask,
		int slots, int slot_width);
		static struct hda_pcm snd_soc_find_pcm_from_dai(struct hdac_hda_priv hda_pvt,
		struct snd_soc_dai *dai);

		static struct snd_soc_dai_ops hdac_hda_dai_ops = {
		.startup = hdac_hda_dai_open,
		.shutdown = hdac_hda_dai_close,
		.prepare = hdac_hda_dai_prepare,
		.hw_free = hdac_hda_dai_hw_free,
		.set_tdm_slot = hdac_hda_dai_set_tdm_slot,
		};

		static struct snd_soc_dai_driver hdac_hda_dais[] = {
		{
		.id = HDAC_ANALOG_DAI_ID,
		.name = "Analog Codec DAI",
		.ops = &hdac_hda_dai_ops,
		.playback = {
		.stream_name = "Analog Codec Playback",
		.channels_min = 1,
		.channels_max = 16,
		.rates = SNDRV_PCM_RATE_8000_192000,
		.formats = STUB_FORMATS,
		.sig_bits = 24,
		},
		.capture = {
		.stream_name = "Analog Codec Capture",
		.channels_min = 1,
		.channels_max = 16,
		.rates = SNDRV_PCM_RATE_8000_192000,
		.formats = STUB_FORMATS,
		.sig_bits = 24,
		},
		},
		{
		.id = HDAC_DIGITAL_DAI_ID,
		.name = "Digital Codec DAI",
		.ops = &hdac_hda_dai_ops,
		.playback = {
		.stream_name = "Digital Codec Playback",
		.channels_min = 1,
		.channels_max = 16,
		.rates = SNDRV_PCM_RATE_8000_192000,
		.formats = STUB_FORMATS,
		.sig_bits = 24,
		},
		.capture = {
		.stream_name = "Digital Codec Capture",
		.channels_min = 1,
		.channels_max = 16,
		.rates = SNDRV_PCM_RATE_8000_192000,
		.formats = STUB_FORMATS,
		.sig_bits = 24,
		},
		},
		{
		.id = HDAC_ALT_ANALOG_DAI_ID,
		.name = "Alt Analog Codec DAI",
		.ops = &hdac_hda_dai_ops,
		.playback = {
		.stream_name = "Alt Analog Codec Playback",
		.channels_min = 1,
		.channels_max = 16,
		.rates = SNDRV_PCM_RATE_8000_192000,
		.formats = STUB_FORMATS,
		.sig_bits = 24,
		},
		.capture = {
		.stream_name = "Alt Analog Codec Capture",
		.channels_min = 1,
		.channels_max = 16,
		.rates = SNDRV_PCM_RATE_8000_192000,
		.formats = STUB_FORMATS,
		.sig_bits = 24,
		},
		}

		};

		static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai,
		unsigned int tx_mask, unsigned int rx_mask,
		int slots, int slot_width)
		{
		struct snd_soc_component *component = dai->component;
		struct hdac_hda_priv *hda_pvt;
		struct hdac_hda_pcm *pcm;

		hda_pvt = snd_soc_component_get_drvdata(component);
		pcm = &hda_pvt->pcm[dai->id];
		if (tx_mask)
		pcm[dai->id].stream_tag[SNDRV_PCM_STREAM_PLAYBACK] = tx_mask;
		else
		pcm[dai->id].stream_tag[SNDRV_PCM_STREAM_CAPTURE] = rx_mask;

		return 0;
		}

		static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai)
		{
		struct snd_soc_component *component = dai->component;
		struct hdac_hda_priv *hda_pvt;
		struct hda_pcm_stream *hda_stream;
		struct hda_pcm *pcm;

		hda_pvt = snd_soc_component_get_drvdata(component);
		pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
		if (!pcm)
		return -EINVAL;

		hda_stream = &pcm->stream[substream->stream];
		snd_hda_codec_cleanup(&hda_pvt->codec, hda_stream, substream);

		return 0;
		}

		static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai)
		{
		struct snd_soc_component *component = dai->component;
		struct hdac_hda_priv *hda_pvt;
		struct snd_pcm_runtime *runtime = substream->runtime;
		struct hdac_device *hdev;
		struct hda_pcm_stream *hda_stream;
		unsigned int format_val;
		struct hda_pcm *pcm;
		unsigned int stream;
		int ret = 0;

		hda_pvt = snd_soc_component_get_drvdata(component);
		hdev = &hda_pvt->codec.core;
		pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
		if (!pcm)
		return -EINVAL;

		hda_stream = &pcm->stream[substream->stream];

		format_val = snd_hdac_calc_stream_format(runtime->rate,
		runtime->channels,
		runtime->format,
		hda_stream->maxbps,
		0);
		if (!format_val) {
		dev_err(&hdev->dev,
		"invalid format_val, rate=%d, ch=%d, format=%d\n",
		runtime->rate, runtime->channels, runtime->format);
		return -EINVAL;
		}

		stream = hda_pvt->pcm[dai->id].stream_tag[substream->stream];

		ret = snd_hda_codec_prepare(&hda_pvt->codec, hda_stream,
		stream, format_val, substream);
		if (ret < 0)
		dev_err(&hdev->dev, "codec prepare failed %d\n", ret);

		return ret;
		}

		static int hdac_hda_dai_open(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai)
		{
		struct snd_soc_component *component = dai->component;
		struct hdac_hda_priv *hda_pvt;
		struct hda_pcm_stream *hda_stream;
		struct hda_pcm *pcm;
		int ret;

		hda_pvt = snd_soc_component_get_drvdata(component);
		pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
		if (!pcm)
		return -EINVAL;

		snd_hda_codec_pcm_get(pcm);

		hda_stream = &pcm->stream[substream->stream];

		ret = hda_stream->ops.open(hda_stream, &hda_pvt->codec, substream);
		if (ret < 0)
		snd_hda_codec_pcm_put(pcm);

		return ret;
		}

		static void hdac_hda_dai_close(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai)
		{
		struct snd_soc_component *component = dai->component;
		struct hdac_hda_priv *hda_pvt;
		struct hda_pcm_stream *hda_stream;
		struct hda_pcm *pcm;

		hda_pvt = snd_soc_component_get_drvdata(component);
		pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
		if (!pcm)
		return;

		hda_stream = &pcm->stream[substream->stream];

		hda_stream->ops.close(hda_stream, &hda_pvt->codec, substream);

		snd_hda_codec_pcm_put(pcm);
		}

		static struct hda_pcm snd_soc_find_pcm_from_dai(struct hdac_hda_priv hda_pvt,
		struct snd_soc_dai *dai)
		{
		struct hda_codec *hcodec = &hda_pvt->codec;
		struct hda_pcm *cpcm;
		const char *pcm_name;

		switch (dai->id) {
		case HDAC_ANALOG_DAI_ID:
		pcm_name = "Analog";
		break;
		case HDAC_DIGITAL_DAI_ID:
		pcm_name = "Digital";
		break;
		case HDAC_ALT_ANALOG_DAI_ID:
		pcm_name = "Alt Analog";
		break;
		default:
		dev_err(&hcodec->core.dev, "invalid dai id %d\n", dai->id);
		return NULL;
		}

		list_for_each_entry(cpcm, &hcodec->pcm_list_head, list) {
		if (strpbrk(cpcm->name, pcm_name))
		return cpcm;
		}

		dev_err(&hcodec->core.dev, "didn't find PCM for DAI %s\n", dai->name);
		return NULL;
		}

		static int hdac_hda_codec_probe(struct snd_soc_component *component)
		{
		struct hdac_hda_priv *hda_pvt =
		snd_soc_component_get_drvdata(component);
		struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
		struct hdac_device *hdev = &hda_pvt->codec.core;
		struct hda_codec *hcodec = &hda_pvt->codec;
		struct hdac_ext_link *hlink;
		hda_codec_patch_t patch;
		int ret;

		hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
		if (!hlink) {
		dev_err(&hdev->dev, "hdac link not found\n");
		return -EIO;
		}

		snd_hdac_ext_bus_link_get(hdev->bus, hlink);

		ret = snd_hda_codec_device_new(hcodec->bus, component->card->snd_card,
		hdev->addr, hcodec);
		if (ret < 0) {
		dev_err(&hdev->dev, "failed to create hda codec %d\n", ret);
		goto error_no_pm;
		}

		/*
		* snd_hda_codec_device_new decrements the usage count so call get pm
		* else the device will be powered off
		*/
		pm_runtime_get_noresume(&hdev->dev);

		hcodec->bus->card = dapm->card->snd_card;

		ret = snd_hda_codec_set_name(hcodec, hcodec->preset->name);
		if (ret < 0) {
		dev_err(&hdev->dev, "name failed %s\n", hcodec->preset->name);
		goto error;
		}

		ret = snd_hdac_regmap_init(&hcodec->core);
		if (ret < 0) {
		dev_err(&hdev->dev, "regmap init failed\n");
		goto error;
		}

		patch = (hda_codec_patch_t)hcodec->preset->driver_data;
		if (patch) {
		ret = patch(hcodec);
		if (ret < 0) {
		dev_err(&hdev->dev, "patch failed %d\n", ret);
		goto error;
		}
		} else {
		dev_dbg(&hdev->dev, "no patch file found\n");
		}

		ret = snd_hda_codec_parse_pcms(hcodec);
		if (ret < 0) {
		dev_err(&hdev->dev, "unable to map pcms to dai %d\n", ret);
		goto error;
		}

		ret = snd_hda_codec_build_controls(hcodec);
		if (ret < 0) {
		dev_err(&hdev->dev, "unable to create controls %d\n", ret);
		goto error;
		}

		hcodec->core.lazy_cache = true;

		/*
		* hdac_device core already sets the state to active and calls
		* get_noresume. So enable runtime and set the device to suspend.
		* pm_runtime_enable is also called during codec registeration
		*/
		pm_runtime_put(&hdev->dev);
		pm_runtime_suspend(&hdev->dev);

		return 0;

		error:
		pm_runtime_put(&hdev->dev);
		error_no_pm:
		snd_hdac_ext_bus_link_put(hdev->bus, hlink);
		return ret;
		}

		static void hdac_hda_codec_remove(struct snd_soc_component *component)
		{
		struct hdac_hda_priv *hda_pvt =
		snd_soc_component_get_drvdata(component);
		struct hdac_device *hdev = &hda_pvt->codec.core;
		struct hdac_ext_link *hlink = NULL;

		hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
		if (!hlink) {
		dev_err(&hdev->dev, "hdac link not found\n");
		return;
		}

		snd_hdac_ext_bus_link_put(hdev->bus, hlink);
		pm_runtime_disable(&hdev->dev);
		}

		static const struct snd_soc_dapm_route hdac_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 hdac_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 const struct snd_soc_component_driver hdac_hda_codec = {
		.probe = hdac_hda_codec_probe,
		.remove = hdac_hda_codec_remove,
		.idle_bias_on = false,
		.dapm_widgets = hdac_hda_dapm_widgets,
		.num_dapm_widgets = ARRAY_SIZE(hdac_hda_dapm_widgets),
		.dapm_routes = hdac_hda_dapm_routes,
		.num_dapm_routes = ARRAY_SIZE(hdac_hda_dapm_routes),
		};

		static int hdac_hda_dev_probe(struct hdac_device *hdev)
		{
		struct hdac_ext_link *hlink;
		struct hdac_hda_priv *hda_pvt;
		int ret;

		/* hold the ref while we probe */
		hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
		if (!hlink) {
		dev_err(&hdev->dev, "hdac link not found\n");
		return -EIO;
		}
		snd_hdac_ext_bus_link_get(hdev->bus, hlink);

		hda_pvt = hdac_to_hda_priv(hdev);
		if (!hda_pvt)
		return -ENOMEM;

		/* ASoC specific initialization */
		ret = snd_soc_register_component(&hdev->dev,
		&hdac_hda_codec, hdac_hda_dais,
		ARRAY_SIZE(hdac_hda_dais));
		if (ret < 0) {
		dev_err(&hdev->dev, "failed to register HDA codec %d\n", ret);
		return ret;
		}

		dev_set_drvdata(&hdev->dev, hda_pvt);
		snd_hdac_ext_bus_link_put(hdev->bus, hlink);

		return ret;
		}

		static int hdac_hda_dev_remove(struct hdac_device *hdev)
		{
		snd_soc_unregister_component(&hdev->dev);
		return 0;
		}

		static struct hdac_ext_bus_ops hdac_ops = {
		.hdev_attach = hdac_hda_dev_probe,
		.hdev_detach = hdac_hda_dev_remove,
		};

		struct hdac_ext_bus_ops *snd_soc_hdac_hda_get_ops(void)
		{
		return &hdac_ops;
		}
		EXPORT_SYMBOL_GPL(snd_soc_hdac_hda_get_ops);

		MODULE_LICENSE("GPL v2");
		MODULE_DESCRIPTION("ASoC Extensions for legacy HDA Drivers");
		MODULE_AUTHOR("Rakesh Ughreja<rakesh.a.ughreja@intel.com>");

sound/soc/codecs/hdac_hda.h

0 → 100644

+24 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* Copyright(c) 2015-18 Intel Corporation.
		*/

		#ifndef __HDAC_HDA_H__
		#define __HDAC_HDA_H__

		struct hdac_hda_pcm {
		int stream_tag[2];
		};

		struct hdac_hda_priv {
		struct hda_codec codec;
		struct hdac_hda_pcm pcm[2];
		};

		#define hdac_to_hda_priv(_hdac) \
		container_of(_hdac, struct hdac_hda_priv, codec.core)
		#define hdac_to_hda_codec(_hdac) container_of(_hdac, struct hda_codec, core)

		struct hdac_ext_bus_ops *snd_soc_hdac_hda_get_ops(void);

		#endif /* __HDAC_HDA_H__ */

Admin message