484 lines
13 KiB
C
484 lines
13 KiB
C
// 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 const 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 = devm_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)
|
|
{
|
|
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>");
|