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

Commit 6f952d59 authored by Damir Didjusto's avatar Damir Didjusto Committed by Gerrit - the friendly Code Review server
Browse files

ASoC: msm: Add support for ASM loopback 



Add ASM loopback driver. When audio path wants to use filters in DSP,
it will do a loopback in ASM.  The new ASM loopback driver enables
the loopback.

Change-Id: I84b81cab6c3b2e57855dd4b3bb5e7ed01618e4ec
Signed-off-by: default avatarDamir Didjusto <damird@codeaurora.org>
Signed-off-by: default avatarVimal Puthanveed <vimalp@codeaurora.org>
parent cadcc68d

Documentation/devicetree/bindings/sound/qcom-audio-dev.txt

+6 −0
Original line number Diff line number Diff line
@@ -123,6 +123,12 @@ Required properties: 


 - compatible : "qcom,msm-lsm-client"



* msm-pcm-loopback



Required properties:



 - compatible : "qti,msm-pcm-loopback"



* msm-dai-q6



[First Level Nodes]

include/sound/q6asm-v2.h

+3 −0
Original line number Diff line number Diff line
@@ -218,6 +218,9 @@ int q6asm_open_read_write(struct audio_client *ac, 
			uint32_t rd_format,

			uint32_t wr_format);



int q6asm_open_loopback_v2(struct audio_client *ac,

			   uint16_t bits_per_sample);



int q6asm_write(struct audio_client *ac, uint32_t len, uint32_t msw_ts,

				uint32_t lsw_ts, uint32_t flags);

int q6asm_write_nolock(struct audio_client *ac, uint32_t len, uint32_t msw_ts,

sound/soc/msm/qdsp6v2/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -4,7 +4,7 @@ snd-soc-qdsp6v2-objs += msm-dai-q6-v2.o msm-pcm-q6-v2.o msm-pcm-routing-v2.o \ 
			msm-pcm-afe-v2.o msm-pcm-voip-v2.o \

			msm-pcm-voice-v2.o msm-dai-q6-hdmi-v2.o \

			msm-lsm-client.o msm-pcm-host-voice-v2.o \

			msm-audio-effects-q6-v2.o

			msm-audio-effects-q6-v2.o msm-pcm-loopback-v2.o

obj-$(CONFIG_SND_SOC_QDSP6V2) += snd-soc-qdsp6v2.o msm-pcm-dtmf-v2.o \

				 msm-dai-stub-v2.o

obj-$(CONFIG_DOLBY_DAP) += msm-dolby-dap-config.o

sound/soc/msm/qdsp6v2/msm-pcm-loopback-v2.c

0 → 100644
+419 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2013, The Linux Foundation. All rights reserved.



* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License version 2 and

* only version 2 as published by the Free Software Foundation.



* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*/



#include <linux/init.h>

#include <linux/err.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/dma-mapping.h>

#include <sound/apr_audio-v2.h>

#include <sound/core.h>

#include <sound/soc.h>

#include <sound/q6asm-v2.h>

#include <sound/pcm.h>

#include <sound/initval.h>

#include <sound/control.h>

#include <sound/tlv.h>

#include <asm/dma.h>



#include "msm-pcm-routing-v2.h"



#define LOOPBACK_VOL_MAX_STEPS 0x2000



static const DECLARE_TLV_DB_LINEAR(loopback_rx_vol_gain, 0,

				LOOPBACK_VOL_MAX_STEPS);



struct msm_pcm_loopback {

	struct snd_pcm_substream *playback_substream;

	struct snd_pcm_substream *capture_substream;



	int instance;



	struct mutex lock;



	uint32_t samp_rate;

	uint32_t channel_mode;



	int playback_start;

	int capture_start;

	int session_id;

	struct audio_client *audio_client;

	int volume;

};



static void stop_pcm(struct msm_pcm_loopback *pcm);



static const struct snd_pcm_hardware dummy_pcm_hardware = {

	.formats                = 0xffffffff,

	.channels_min           = 1,

	.channels_max           = UINT_MAX,



	/* Random values to keep userspace happy when checking constraints */

	.info                   = SNDRV_PCM_INFO_INTERLEAVED |

				  SNDRV_PCM_INFO_BLOCK_TRANSFER,

	.buffer_bytes_max       = 128*1024,

	.period_bytes_min       = 1024,

	.period_bytes_max       = 1024*2,

	.periods_min            = 2,

	.periods_max            = 128,

};



static void msm_pcm_loopback_event_handler(uint32_t opcode, uint32_t token,

					   uint32_t *payload, void *priv)

{

	pr_debug("%s\n", __func__);

	switch (opcode) {

	case APR_BASIC_RSP_RESULT: {

		switch (payload[0]) {

			break;

		default:

			break;

		}

	}

		break;

	default:

		pr_err("Not Supported Event opcode[0x%x]\n", opcode);

		break;

	}

}



static int pcm_loopback_set_volume(struct msm_pcm_loopback *prtd, int volume)

{

	int rc = -EINVAL;



	pr_debug("%s Setting volume 0x%x\n", __func__, volume);



	if (prtd && prtd->audio_client) {

		rc = q6asm_set_volume(prtd->audio_client, volume);

		if (rc < 0) {

			pr_err("%s: Send Volume command failed rc = %d\n",

				__func__, rc);

			return rc;

		}

		prtd->volume = volume;

	}

	return rc;

}



static int msm_pcm_open(struct snd_pcm_substream *substream)

{

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);

	struct msm_pcm_loopback *pcm;

	int ret = 0;

	uint16_t bits_per_sample = 16;



	pcm = dev_get_drvdata(rtd->platform->dev);

	mutex_lock(&pcm->lock);



	snd_soc_set_runtime_hwparams(substream, &dummy_pcm_hardware);

	pcm->volume = 0x2000;



	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

		pcm->playback_substream = substream;

	else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)

		pcm->capture_substream = substream;



	pcm->instance++;

	dev_dbg(rtd->platform->dev, "%s: pcm out open: %d,%d\n", __func__,

			pcm->instance, substream->stream);

	if (pcm->instance == 2) {

		struct snd_soc_pcm_runtime *soc_pcm_rx =

				pcm->playback_substream->private_data;

		struct snd_soc_pcm_runtime *soc_pcm_tx =

				pcm->capture_substream->private_data;

		if (pcm->audio_client != NULL)

			stop_pcm(pcm);



		pcm->audio_client = q6asm_audio_client_alloc(

				(app_cb)msm_pcm_loopback_event_handler, pcm);

		if (!pcm->audio_client) {

			dev_err(rtd->platform->dev,

				"%s: Could not allocate memory\n", __func__);

			mutex_unlock(&pcm->lock);

			return -ENOMEM;

		}

		pcm->session_id = pcm->audio_client->session;

		pcm->audio_client->perf_mode = false;

		ret = q6asm_open_loopback_v2(pcm->audio_client,

					     bits_per_sample);

		if (ret < 0) {

			dev_err(rtd->platform->dev,

				"%s: pcm out open failed\n", __func__);

			q6asm_audio_client_free(pcm->audio_client);

			mutex_unlock(&pcm->lock);

			return -ENOMEM;

		}

		msm_pcm_routing_reg_phy_stream(soc_pcm_tx->dai_link->be_id,

			pcm->audio_client->perf_mode,

			pcm->session_id, pcm->capture_substream->stream);

		msm_pcm_routing_reg_phy_stream(soc_pcm_rx->dai_link->be_id,

			pcm->audio_client->perf_mode,

			pcm->session_id, pcm->playback_substream->stream);

		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

			pcm->playback_substream = substream;

			ret = pcm_loopback_set_volume(pcm, pcm->volume);

			if (ret < 0)

				dev_err(rtd->platform->dev,

					"Error %d setting volume", ret);

		}

	}

	dev_info(rtd->platform->dev, "%s: Instance = %d, Stream ID = %s\n",

			__func__ , pcm->instance, substream->pcm->id);

	runtime->private_data = pcm;



	mutex_unlock(&pcm->lock);



	return 0;

}



static void stop_pcm(struct msm_pcm_loopback *pcm)

{

	struct snd_soc_pcm_runtime *soc_pcm_rx =

		pcm->playback_substream->private_data;

	struct snd_soc_pcm_runtime *soc_pcm_tx =

		pcm->capture_substream->private_data;



	if (pcm->audio_client == NULL)

		return;

	q6asm_cmd(pcm->audio_client, CMD_CLOSE);



	msm_pcm_routing_dereg_phy_stream(soc_pcm_rx->dai_link->be_id,

			SNDRV_PCM_STREAM_PLAYBACK);

	msm_pcm_routing_dereg_phy_stream(soc_pcm_tx->dai_link->be_id,

			SNDRV_PCM_STREAM_CAPTURE);

	q6asm_audio_client_free(pcm->audio_client);

	pcm->audio_client = NULL;

}



static int msm_pcm_close(struct snd_pcm_substream *substream)

{

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct msm_pcm_loopback *pcm = runtime->private_data;

	struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);

	int ret = 0;



	mutex_lock(&pcm->lock);



	dev_dbg(rtd->platform->dev, "%s: end pcm call:%d\n",

		__func__, substream->stream);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

		pcm->playback_start = 0;

	else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)

		pcm->capture_start = 0;



	pcm->instance--;

	if (!pcm->playback_start || !pcm->capture_start) {

		dev_dbg(rtd->platform->dev, "%s: end pcm call\n", __func__);

		stop_pcm(pcm);

	}



	mutex_unlock(&pcm->lock);

	return ret;

}



static int msm_pcm_prepare(struct snd_pcm_substream *substream)

{

	int ret = 0;

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct msm_pcm_loopback *pcm = runtime->private_data;

	struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);



	mutex_lock(&pcm->lock);



	dev_dbg(rtd->platform->dev, "%s: ASM loopback stream:%d\n",

		__func__, substream->stream);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

		if (!pcm->playback_start)

			pcm->playback_start = 1;

	} else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {

		if (!pcm->capture_start)

			pcm->capture_start = 1;

	}

	mutex_unlock(&pcm->lock);



	return ret;

}



static int msm_pcm_trigger(struct snd_pcm_substream *substream, int cmd)

{

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct msm_pcm_loopback *pcm = runtime->private_data;

	struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);



	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_RESUME:

	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:

		dev_dbg(rtd->platform->dev,

			"%s: playback_start:%d,capture_start:%d\n", __func__,

			pcm->playback_start, pcm->capture_start);

		if (pcm->playback_start && pcm->capture_start)

			q6asm_run_nowait(pcm->audio_client, 0, 0, 0);

		break;

	case SNDRV_PCM_TRIGGER_SUSPEND:

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:

	case SNDRV_PCM_TRIGGER_STOP:

		dev_dbg(rtd->platform->dev,

			"%s:Pause/Stop - playback_start:%d,capture_start:%d\n",

			__func__, pcm->playback_start, pcm->capture_start);

		if (pcm->playback_start && pcm->capture_start)

			q6asm_cmd_nowait(pcm->audio_client, CMD_PAUSE);

		break;

	default:

		break;

	}



	return 0;

}



static int msm_pcm_hw_params(struct snd_pcm_substream *substream,

			     struct snd_pcm_hw_params *params)

{

	struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);



	dev_dbg(rtd->platform->dev, "%s: ASM loopback\n", __func__);



	return snd_pcm_lib_alloc_vmalloc_buffer(substream,

		params_buffer_bytes(params));

}



static int msm_pcm_hw_free(struct snd_pcm_substream *substream)

{

	return snd_pcm_lib_free_vmalloc_buffer(substream);

}



static struct snd_pcm_ops msm_pcm_ops = {

	.open           = msm_pcm_open,

	.hw_params      = msm_pcm_hw_params,

	.hw_free        = msm_pcm_hw_free,

	.close          = msm_pcm_close,

	.prepare        = msm_pcm_prepare,

	.trigger        = msm_pcm_trigger,

};



static int msm_pcm_volume_ctl_put(struct snd_kcontrol *kcontrol,

				  struct snd_ctl_elem_value *ucontrol)

{

	int rc = 0;

	struct snd_pcm_volume *vol = kcontrol->private_data;

	struct snd_pcm_substream *substream = vol->pcm->streams[0].substream;

	struct msm_pcm_loopback *prtd = substream->runtime->private_data;

	int volume = ucontrol->value.integer.value[0];



	rc = pcm_loopback_set_volume(prtd, volume);

	return rc;

}



static int msm_pcm_add_controls(struct snd_soc_pcm_runtime *rtd)

{

	struct snd_pcm *pcm = rtd->pcm->streams[0].pcm;

	struct snd_pcm_volume *volume_info;

	struct snd_kcontrol *kctl;

	int ret = 0;



	dev_dbg(rtd->dev, "%s, Volume cntrl add\n", __func__);

	ret = snd_pcm_add_volume_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,

				      NULL, 1,

				      rtd->dai_link->be_id,

				      &volume_info);

	if (ret < 0)

		return ret;

	kctl = volume_info->kctl;

	kctl->put = msm_pcm_volume_ctl_put;

	kctl->tlv.p = loopback_rx_vol_gain;

	return 0;

}



static int msm_asoc_pcm_new(struct snd_soc_pcm_runtime *rtd)

{

	struct snd_card *card = rtd->card->snd_card;

	int ret = 0;



	if (!card->dev->coherent_dma_mask)

		card->dev->coherent_dma_mask = DMA_BIT_MASK(32);



	ret = msm_pcm_add_controls(rtd);

	if (ret)

		dev_err(rtd->dev, "%s, kctl add failed\n", __func__);

	return ret;

}



static struct snd_soc_platform_driver msm_soc_platform = {

	.ops            = &msm_pcm_ops,

	.pcm_new        = msm_asoc_pcm_new,

};



static int msm_pcm_probe(struct platform_device *pdev)

{

	struct msm_pcm_loopback *pcm;



	dev_set_name(&pdev->dev, "%s", "msm-pcm-loopback");



	dev_dbg(&pdev->dev, "%s: dev name %s\n",

		__func__, dev_name(&pdev->dev));



	pcm = kzalloc(sizeof(struct msm_pcm_loopback), GFP_KERNEL);

	if (!pcm) {

		dev_err(&pdev->dev, "%s Failed to allocate memory for pcm\n",

			__func__);

		return -ENOMEM;

	} else {

		mutex_init(&pcm->lock);

		dev_set_drvdata(&pdev->dev, pcm);

	}

	return snd_soc_register_platform(&pdev->dev,

				   &msm_soc_platform);

}



static int msm_pcm_remove(struct platform_device *pdev)

{

	struct msm_pcm_loopback *pcm;



	pcm = dev_get_drvdata(&pdev->dev);

	mutex_destroy(&pcm->lock);

	kfree(pcm);



	snd_soc_unregister_platform(&pdev->dev);

	return 0;

}



static const struct of_device_id msm_pcm_loopback_dt_match[] = {

	{.compatible = "qti,msm-pcm-loopback"},

	{}

};



static struct platform_driver msm_pcm_driver = {

	.driver = {

		.name = "msm-pcm-loopback",

		.owner = THIS_MODULE,

		.of_match_table = msm_pcm_loopback_dt_match,

	},

	.probe = msm_pcm_probe,

	.remove = msm_pcm_remove,

};



static int __init msm_soc_platform_init(void)

{

	return platform_driver_register(&msm_pcm_driver);

}

module_init(msm_soc_platform_init);



static void __exit msm_soc_platform_exit(void)

{

	platform_driver_unregister(&msm_pcm_driver);

}

module_exit(msm_soc_platform_exit);



MODULE_DESCRIPTION("PCM loopback platform driver");

MODULE_LICENSE("GPL v2");

sound/soc/msm/qdsp6v2/q6asm.c

+44 −0
Original line number Diff line number Diff line
@@ -1255,6 +1255,7 @@ static int32_t q6asm_callback(struct apr_client_data *data, void *priv) 
		case ASM_STREAM_CMD_OPEN_READ_V3:

		case ASM_STREAM_CMD_OPEN_WRITE_V3:

		case ASM_STREAM_CMD_OPEN_READWRITE_V2:

		case ASM_STREAM_CMD_OPEN_LOOPBACK_V2:

		case ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2:

		case ASM_STREAM_CMD_SET_ENCDEC_PARAM:

		case ASM_CMD_ADD_TOPOLOGIES:
@@ -1976,6 +1977,49 @@ fail_cmd: 
	return -EINVAL;

}



int q6asm_open_loopback_v2(struct audio_client *ac, uint16_t bits_per_sample)

{

	int rc = 0x00;

	struct asm_stream_cmd_open_loopback_v2 open;



	if ((ac == NULL) || (ac->apr == NULL)) {

		pr_err("%s APR handle NULL\n", __func__);

		return -EINVAL;

	}

	pr_debug("%s: session[%d]", __func__, ac->session);



	q6asm_add_hdr(ac, &open.hdr, sizeof(open), TRUE);

	open.hdr.opcode = ASM_STREAM_CMD_OPEN_LOOPBACK_V2;



	open.mode_flags = 0;

	open.src_endpointype = 0;

	open.sink_endpointype = 0;

	/* source endpoint : matrix */

	open.postprocopo_id = get_asm_topology();

	if (open.postprocopo_id == 0)

		open.postprocopo_id = DEFAULT_POPP_TOPOLOGY;

	open.bits_per_sample = bits_per_sample;

	open.reserved = 0;



	rc = apr_send_pkt(ac->apr, (uint32_t *) &open);

	if (rc < 0) {

		pr_err("%s open failed op[0x%x]rc[%d]\n", __func__,

			open.hdr.opcode, rc);

		goto fail_cmd;

	}



	rc = wait_event_timeout(ac->cmd_wait,

			(atomic_read(&ac->cmd_state) == 0), 5*HZ);

	if (!rc) {

		pr_err("%s timeout. waited for open_loopback rc[%d]\n",

			__func__, rc);

		goto fail_cmd;

	}

	return 0;

fail_cmd:

	return -EINVAL;

}



int q6asm_run(struct audio_client *ac, uint32_t flags,

		uint32_t msw_ts, uint32_t lsw_ts)

{