Unverified Commit 7cb37b7b authored by V Sujith Kumar Reddy's avatar V Sujith Kumar Reddy Committed by Mark Brown
Browse files

ASoC: qcom: Add support for lpass hdmi driver 



Upadate lpass cpu and platform driver to support audio over dp.
Also add lpass-hdmi.c and lpass-hdmi.h.

Signed-off-by: default avatarV Sujith Kumar Reddy <vsujithk@codeaurora.org>
Signed-off-by: default avatarSrinivasa Rao <srivasam@codeaurora.org>
Reviewed-by: default avatarSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Tested-by: default avatarSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Link: https://lore.kernel.org/r/1602134223-2562-6-git-send-email-srivasam@codeaurora.org


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent d9e8e612

sound/soc/qcom/Kconfig

+5 −0
Original line number Diff line number Diff line
@@ -12,6 +12,10 @@ config SND_SOC_LPASS_CPU 
	tristate

	select REGMAP_MMIO



config SND_SOC_LPASS_HDMI

	tristate

	select REGMAP_MMIO



config SND_SOC_LPASS_PLATFORM

	tristate

	select REGMAP_MMIO
@@ -30,6 +34,7 @@ config SND_SOC_LPASS_SC7180 
	tristate

	select SND_SOC_LPASS_CPU

	select SND_SOC_LPASS_PLATFORM

	select SND_SOC_LPASS_HDMI



config SND_SOC_STORM

	tristate "ASoC I2S support for Storm boards"

sound/soc/qcom/Makefile

+2 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

# Platform

snd-soc-lpass-cpu-objs := lpass-cpu.o

snd-soc-lpass-hdmi-objs := lpass-hdmi.o

snd-soc-lpass-platform-objs := lpass-platform.o

snd-soc-lpass-ipq806x-objs := lpass-ipq806x.o

snd-soc-lpass-apq8016-objs := lpass-apq8016.o

snd-soc-lpass-sc7180-objs := lpass-sc7180.o



obj-$(CONFIG_SND_SOC_LPASS_CPU) += snd-soc-lpass-cpu.o

obj-$(CONFIG_SND_SOC_LPASS_HDMI) += snd-soc-lpass-hdmi.o

obj-$(CONFIG_SND_SOC_LPASS_PLATFORM) += snd-soc-lpass-platform.o

obj-$(CONFIG_SND_SOC_LPASS_IPQ806X) += snd-soc-lpass-ipq806x.o

obj-$(CONFIG_SND_SOC_LPASS_APQ8016) += snd-soc-lpass-apq8016.o

sound/soc/qcom/lpass-apq8016.c

+2 −2
Original line number Diff line number Diff line
@@ -125,7 +125,7 @@ static struct snd_soc_dai_driver apq8016_lpass_cpu_dai_driver[] = { 
};



static int apq8016_lpass_alloc_dma_channel(struct lpass_data *drvdata,

					   int direction)

					   int direction, unsigned int dai_id)

{

	struct lpass_variant *v = drvdata->variant;

	int chan = 0;
@@ -151,7 +151,7 @@ static int apq8016_lpass_alloc_dma_channel(struct lpass_data *drvdata, 
	return chan;

}



static int apq8016_lpass_free_dma_channel(struct lpass_data *drvdata, int chan)

static int apq8016_lpass_free_dma_channel(struct lpass_data *drvdata, int chan, unsigned int dai_id)

{

	clear_bit(chan, &drvdata->dma_ch_bit_map);

sound/soc/qcom/lpass-cpu.c

+241 −6
Original line number Diff line number Diff line
@@ -478,6 +478,206 @@ static struct regmap_config lpass_cpu_regmap_config = { 
	.cache_type = REGCACHE_FLAT,

};



static int lpass_hdmi_init_bitfields(struct device *dev, struct regmap *map)

{

	struct lpass_data *drvdata = dev_get_drvdata(dev);

	struct lpass_variant *v = drvdata->variant;

	unsigned int i;

	struct lpass_hdmi_tx_ctl *tx_ctl;

	struct regmap_field *legacy_en;

	struct lpass_vbit_ctrl *vbit_ctl;

	struct regmap_field *tx_parity;

	struct lpass_dp_metadata_ctl *meta_ctl;

	struct lpass_sstream_ctl *sstream_ctl;

	struct regmap_field *ch_msb;

	struct regmap_field *ch_lsb;

	struct lpass_hdmitx_dmactl *tx_dmactl;

	int rval;



	tx_ctl = devm_kzalloc(dev, sizeof(*tx_ctl), GFP_KERNEL);

	if (!tx_ctl)

		return -ENOMEM;



	QCOM_REGMAP_FIELD_ALLOC(dev, map, v->soft_reset, tx_ctl->soft_reset);

	QCOM_REGMAP_FIELD_ALLOC(dev, map, v->force_reset, tx_ctl->force_reset);

	drvdata->tx_ctl = tx_ctl;



	QCOM_REGMAP_FIELD_ALLOC(dev, map, v->legacy_en, legacy_en);

	drvdata->hdmitx_legacy_en = legacy_en;



	vbit_ctl = devm_kzalloc(dev, sizeof(*vbit_ctl), GFP_KERNEL);

	if (!vbit_ctl)

		return -ENOMEM;



	QCOM_REGMAP_FIELD_ALLOC(dev, map, v->replace_vbit, vbit_ctl->replace_vbit);

	QCOM_REGMAP_FIELD_ALLOC(dev, map, v->vbit_stream, vbit_ctl->vbit_stream);

	drvdata->vbit_ctl = vbit_ctl;





	QCOM_REGMAP_FIELD_ALLOC(dev, map, v->calc_en, tx_parity);

	drvdata->hdmitx_parity_calc_en = tx_parity;



	meta_ctl = devm_kzalloc(dev, sizeof(*meta_ctl), GFP_KERNEL);

	if (!meta_ctl)

		return -ENOMEM;



	rval = devm_regmap_field_bulk_alloc(dev, map, &meta_ctl->mute, &v->mute, 7);

	if (rval)

		return rval;

	drvdata->meta_ctl = meta_ctl;



	sstream_ctl = devm_kzalloc(dev, sizeof(*sstream_ctl), GFP_KERNEL);

	if (!sstream_ctl)

		return -ENOMEM;



	rval = devm_regmap_field_bulk_alloc(dev, map, &sstream_ctl->sstream_en, &v->sstream_en, 9);

	if (rval)

		return rval;



	drvdata->sstream_ctl = sstream_ctl;



	for (i = 0; i < LPASS_MAX_HDMI_DMA_CHANNELS; i++) {

		QCOM_REGMAP_FIELD_ALLOC(dev, map, v->msb_bits, ch_msb);

		drvdata->hdmitx_ch_msb[i] = ch_msb;



		QCOM_REGMAP_FIELD_ALLOC(dev, map, v->lsb_bits, ch_lsb);

		drvdata->hdmitx_ch_lsb[i] = ch_lsb;



		tx_dmactl = devm_kzalloc(dev, sizeof(*tx_dmactl), GFP_KERNEL);

		if (!tx_dmactl)

			return -ENOMEM;



		QCOM_REGMAP_FIELD_ALLOC(dev, map, v->use_hw_chs, tx_dmactl->use_hw_chs);

		QCOM_REGMAP_FIELD_ALLOC(dev, map, v->use_hw_usr, tx_dmactl->use_hw_usr);

		QCOM_REGMAP_FIELD_ALLOC(dev, map, v->hw_chs_sel, tx_dmactl->hw_chs_sel);

		QCOM_REGMAP_FIELD_ALLOC(dev, map, v->hw_usr_sel, tx_dmactl->hw_usr_sel);

		drvdata->hdmi_tx_dmactl[i] = tx_dmactl;

	}

	return 0;

}



static bool lpass_hdmi_regmap_writeable(struct device *dev, unsigned int reg)

{

	struct lpass_data *drvdata = dev_get_drvdata(dev);

	struct lpass_variant *v = drvdata->variant;

	int i;



	if (reg == LPASS_HDMI_TX_CTL_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_LEGACY_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_VBIT_CTL_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_PARITY_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_DP_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_SSTREAM_ADDR(v))

		return true;

	if (reg == LPASS_HDMITX_APP_IRQEN_REG(v))

		return true;

	if (reg == LPASS_HDMITX_APP_IRQCLEAR_REG(v))

		return true;



	for (i = 0; i < v->hdmi_rdma_channels; i++) {

		if (reg == LPASS_HDMI_TX_CH_LSB_ADDR(v, i))

			return true;

		if (reg == LPASS_HDMI_TX_CH_MSB_ADDR(v, i))

			return true;

		if (reg == LPASS_HDMI_TX_DMA_ADDR(v, i))

			return true;

	}



	for (i = 0; i < v->rdma_channels; ++i) {

		if (reg == LPAIF_HDMI_RDMACTL_REG(v, i))

			return true;

		if (reg == LPAIF_HDMI_RDMABASE_REG(v, i))

			return true;

		if (reg == LPAIF_HDMI_RDMABUFF_REG(v, i))

			return true;

		if (reg == LPAIF_HDMI_RDMAPER_REG(v, i))

			return true;

	}

	return false;

}



static bool lpass_hdmi_regmap_readable(struct device *dev, unsigned int reg)

{

	struct lpass_data *drvdata = dev_get_drvdata(dev);

	struct lpass_variant *v = drvdata->variant;

	int i;



	if (reg == LPASS_HDMI_TX_CTL_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_LEGACY_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_VBIT_CTL_ADDR(v))

		return true;



	for (i = 0; i < v->hdmi_rdma_channels; i++) {

		if (reg == LPASS_HDMI_TX_CH_LSB_ADDR(v, i))

			return true;

		if (reg == LPASS_HDMI_TX_CH_MSB_ADDR(v, i))

			return true;

		if (reg == LPASS_HDMI_TX_DMA_ADDR(v, i))

			return true;

	}



	if (reg == LPASS_HDMI_TX_PARITY_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_DP_ADDR(v))

		return true;

	if (reg == LPASS_HDMI_TX_SSTREAM_ADDR(v))

		return true;

	if (reg == LPASS_HDMITX_APP_IRQEN_REG(v))

		return true;

	if (reg == LPASS_HDMITX_APP_IRQSTAT_REG(v))

		return true;



	for (i = 0; i < v->rdma_channels; ++i) {

		if (reg == LPAIF_HDMI_RDMACTL_REG(v, i))

			return true;

		if (reg == LPAIF_HDMI_RDMABASE_REG(v, i))

			return true;

		if (reg == LPAIF_HDMI_RDMABUFF_REG(v, i))

			return true;

		if (reg == LPAIF_HDMI_RDMAPER_REG(v, i))

			return true;

		if (reg == LPAIF_HDMI_RDMACURR_REG(v, i))

			return true;

	}



	return false;

}



static bool lpass_hdmi_regmap_volatile(struct device *dev, unsigned int reg)

{

	struct lpass_data *drvdata = dev_get_drvdata(dev);

	struct lpass_variant *v = drvdata->variant;

	int i;



	if (reg == LPASS_HDMITX_APP_IRQSTAT_REG(v))

		return true;

	if (reg == LPASS_HDMI_TX_LEGACY_ADDR(v))

		return true;



	for (i = 0; i < v->rdma_channels; ++i) {

		if (reg == LPAIF_HDMI_RDMACURR_REG(v, i))

			return true;

	}

	return false;

}



struct regmap_config lpass_hdmi_regmap_config = {

	.reg_bits = 32,

	.reg_stride = 4,

	.val_bits = 32,

	.writeable_reg = lpass_hdmi_regmap_writeable,

	.readable_reg = lpass_hdmi_regmap_readable,

	.volatile_reg = lpass_hdmi_regmap_volatile,

	.cache_type = REGCACHE_FLAT,

};



static unsigned int of_lpass_cpu_parse_sd_lines(struct device *dev,

						struct device_node *node,

						const char *name)
@@ -535,7 +735,10 @@ static void of_lpass_cpu_parse_dai_data(struct device *dev, 
			dev_err(dev, "valid dai id not found: %d\n", ret);

			continue;

		}



		if (id == LPASS_DP_RX) {

			data->hdmi_port_enable = 1;

			dev_err(dev, "HDMI Port is enabled: %d\n", id);

		} else {

			data->mi2s_playback_sd_mode[id] =

				of_lpass_cpu_parse_sd_lines(dev, node,

							    "qcom,playback-sd-lines");
@@ -544,6 +747,7 @@ static void of_lpass_cpu_parse_dai_data(struct device *dev, 
						    "qcom,capture-sd-lines");

		}

	}

}



int asoc_qcom_lpass_cpu_platform_probe(struct platform_device *pdev)

{
@@ -596,6 +800,27 @@ int asoc_qcom_lpass_cpu_platform_probe(struct platform_device *pdev) 
		return PTR_ERR(drvdata->lpaif_map);

	}



	if (drvdata->hdmi_port_enable) {

		res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpass-hdmiif");



		drvdata->hdmiif = devm_ioremap_resource(dev, res);

		if (IS_ERR((void const __force *)drvdata->hdmiif)) {

			dev_err(dev, "error mapping reg resource: %ld\n",

					PTR_ERR((void const __force *)drvdata->hdmiif));

			return PTR_ERR((void const __force *)drvdata->hdmiif);

		}



		lpass_hdmi_regmap_config.max_register = LPAIF_HDMI_RDMAPER_REG(variant,

					variant->hdmi_rdma_channels);

		drvdata->hdmiif_map = devm_regmap_init_mmio(dev, drvdata->hdmiif,

					&lpass_hdmi_regmap_config);

		if (IS_ERR(drvdata->hdmiif_map)) {

			dev_err(dev, "error initializing regmap: %ld\n",

			PTR_ERR(drvdata->hdmiif_map));

			return PTR_ERR(drvdata->hdmiif_map);

		}

	}



	if (variant->init) {

		ret = variant->init(pdev);

		if (ret) {
@@ -606,6 +831,9 @@ int asoc_qcom_lpass_cpu_platform_probe(struct platform_device *pdev) 


	for (i = 0; i < variant->num_dai; i++) {

		dai_id = variant->dai_driver[i].id;

		if (dai_id == LPASS_DP_RX)

			continue;



		drvdata->mi2s_osr_clk[dai_id] = devm_clk_get(dev,

					     variant->dai_osr_clk_names[i]);

		if (IS_ERR(drvdata->mi2s_osr_clk[dai_id])) {
@@ -641,6 +869,13 @@ int asoc_qcom_lpass_cpu_platform_probe(struct platform_device *pdev) 
		return ret;

	}



	if (drvdata->hdmi_port_enable) {

		ret = lpass_hdmi_init_bitfields(dev, drvdata->hdmiif_map);

		if (ret) {

			dev_err(dev, "%s error  hdmi init failed\n", __func__);

			return ret;

		}

	}

	ret = devm_snd_soc_register_component(dev,

					      &lpass_cpu_comp_driver,

					      variant->dai_driver,

sound/soc/qcom/lpass-hdmi.c

0 → 100644
+258 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2020 The Linux Foundation. All rights reserved.

 *

 * lpass-hdmi.c -- ALSA SoC HDMI-CPU DAI driver for QTi LPASS HDMI

 */





#include <linux/kernel.h>

#include <linux/module.h>

#include <sound/pcm_params.h>

#include <linux/regmap.h>

#include <sound/soc.h>

#include <sound/soc-dai.h>

#include <dt-bindings/sound/sc7180-lpass.h>

#include "lpass-lpaif-reg.h"

#include "lpass.h"



static int lpass_hdmi_daiops_hw_params(struct snd_pcm_substream *substream,

		struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)

{

	struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);

	snd_pcm_format_t format = params_format(params);

	unsigned int rate = params_rate(params);

	unsigned int channels = params_channels(params);

	unsigned int ret;

	unsigned int bitwidth;

	unsigned int word_length;

	unsigned int ch_sts_buf0;

	unsigned int ch_sts_buf1;

	unsigned int data_format;

	unsigned int sampling_freq;

	unsigned int ch = 0;

	struct lpass_dp_metadata_ctl *meta_ctl = drvdata->meta_ctl;

	struct lpass_sstream_ctl *sstream_ctl = drvdata->sstream_ctl;



	bitwidth = snd_pcm_format_width(format);

	if (bitwidth < 0) {

		dev_err(dai->dev, "%s invalid bit width given : %d\n",

					__func__, bitwidth);

		return bitwidth;

	}



	switch (bitwidth) {

	case 16:

		word_length = LPASS_DP_AUDIO_BITWIDTH16;

		break;

	case 24:

		word_length = LPASS_DP_AUDIO_BITWIDTH24;

		break;

	default:

		dev_err(dai->dev, "%s invalid bit width given : %d\n",

					__func__, bitwidth);

		return -EINVAL;

	}



	switch (rate) {

	case 32000:

		sampling_freq = LPASS_SAMPLING_FREQ32;

		break;

	case 44100:

		sampling_freq = LPASS_SAMPLING_FREQ44;

		break;

	case 48000:

		sampling_freq = LPASS_SAMPLING_FREQ48;

		break;

	default:

		dev_err(dai->dev, "%s invalid bit width given : %d\n",

					__func__, bitwidth);

		return -EINVAL;

	}

	data_format = LPASS_DATA_FORMAT_LINEAR;

	ch_sts_buf0 = (((data_format << LPASS_DATA_FORMAT_SHIFT) & LPASS_DATA_FORMAT_MASK)

				| ((sampling_freq << LPASS_FREQ_BIT_SHIFT) & LPASS_FREQ_BIT_MASK));

	ch_sts_buf1 = (word_length) & LPASS_WORDLENGTH_MASK;



	ret = regmap_field_write(drvdata->tx_ctl->soft_reset, LPASS_TX_CTL_RESET);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->tx_ctl->soft_reset, LPASS_TX_CTL_CLEAR);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmitx_legacy_en, LPASS_HDMITX_LEGACY_DISABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmitx_parity_calc_en, HDMITX_PARITY_CALC_EN);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->vbit_ctl->replace_vbit, REPLACE_VBIT);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->vbit_ctl->vbit_stream, LINEAR_PCM_DATA);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmitx_ch_msb[0], ch_sts_buf1);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmitx_ch_lsb[0], ch_sts_buf0);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmi_tx_dmactl[0]->use_hw_chs, HW_MODE);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmi_tx_dmactl[0]->hw_chs_sel, SW_MODE);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmi_tx_dmactl[0]->use_hw_usr, HW_MODE);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->hdmi_tx_dmactl[0]->hw_usr_sel, SW_MODE);

	if (ret)

		return ret;



	ret = regmap_field_write(meta_ctl->mute, LPASS_MUTE_ENABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(meta_ctl->as_sdp_cc, channels - 1);

	if (ret)

		return ret;



	ret = regmap_field_write(meta_ctl->as_sdp_ct, LPASS_META_DEFAULT_VAL);

	if (ret)

		return ret;



	ret = regmap_field_write(meta_ctl->aif_db4, LPASS_META_DEFAULT_VAL);

	if (ret)

		return ret;



	ret = regmap_field_write(meta_ctl->frequency, sampling_freq);

	if (ret)

		return ret;



	ret = regmap_field_write(meta_ctl->mst_index, LPASS_META_DEFAULT_VAL);

	if (ret)

		return ret;



	ret = regmap_field_write(meta_ctl->dptx_index, LPASS_META_DEFAULT_VAL);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->sstream_en, LPASS_SSTREAM_DISABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->dma_sel, ch);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->auto_bbit_en, LPASS_SSTREAM_DEFAULT_ENABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->layout, LPASS_SSTREAM_DEFAULT_DISABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->layout_sp, LPASS_LAYOUT_SP_DEFAULT);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->dp_audio, LPASS_SSTREAM_DEFAULT_ENABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->set_sp_on_en, LPASS_SSTREAM_DEFAULT_ENABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->dp_sp_b_hw_en, LPASS_SSTREAM_DEFAULT_ENABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(sstream_ctl->dp_staffing_en, LPASS_SSTREAM_DEFAULT_ENABLE);

	if (ret)

		return ret;



	return ret;

}



static int lpass_hdmi_daiops_prepare(struct snd_pcm_substream *substream,

		struct snd_soc_dai *dai)

{

	int ret;

	struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);



	ret = regmap_field_write(drvdata->sstream_ctl->sstream_en, LPASS_SSTREAM_ENABLE);

	if (ret)

		return ret;



	ret = regmap_field_write(drvdata->meta_ctl->mute, LPASS_MUTE_DISABLE);

	if (ret)

		return ret;



	return ret;

}



static int lpass_hdmi_daiops_trigger(struct snd_pcm_substream *substream,

		int cmd, struct snd_soc_dai *dai)

{

	struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);

	struct lpass_dp_metadata_ctl *meta_ctl = drvdata->meta_ctl;

	struct lpass_sstream_ctl *sstream_ctl = drvdata->sstream_ctl;

	int ret = -EINVAL;



	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_RESUME:

	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:

		ret = regmap_field_write(sstream_ctl->sstream_en, LPASS_SSTREAM_ENABLE);

		if (ret)

			return ret;



		ret = regmap_field_write(meta_ctl->mute, LPASS_MUTE_DISABLE);

		if (ret)

			return ret;



		break;

	case SNDRV_PCM_TRIGGER_STOP:

	case SNDRV_PCM_TRIGGER_SUSPEND:

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:

		ret = regmap_field_write(sstream_ctl->sstream_en, LPASS_SSTREAM_DISABLE);

		if (ret)

			return ret;



		ret = regmap_field_write(meta_ctl->mute, LPASS_MUTE_ENABLE);

		if (ret)

			return ret;



		ret = regmap_field_write(sstream_ctl->dp_audio, 0);

		if (ret)

			return ret;



		break;

	}

	return ret;

}



const struct snd_soc_dai_ops asoc_qcom_lpass_hdmi_dai_ops = {

	.hw_params	= lpass_hdmi_daiops_hw_params,

	.prepare	= lpass_hdmi_daiops_prepare,

	.trigger	= lpass_hdmi_daiops_trigger,

};

EXPORT_SYMBOL_GPL(asoc_qcom_lpass_hdmi_dai_ops);



MODULE_DESCRIPTION("QTi LPASS HDMI Driver");

MODULE_LICENSE("GPL v2");