Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Unverified Commit 6bae5ea9 authored by Rakesh Ughreja's avatar Rakesh Ughreja Committed by Mark Brown
Browse files

ASoC: hdac_hda: add asoc extension for legacy HDA codec drivers 



This patch adds a kernel module which is used by the legacy HDA
codec drivers as library. This implements hdac_ext_bus_ops to enable
the reuse of legacy HDA codec drivers with ASoC platform drivers.

Signed-off-by: default avatarRakesh Ughreja <rakesh.a.ughreja@intel.com>
Signed-off-by: default avatarPierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 00deadb5

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