[linux-2.6-block.git] / sound / soc / qcom / sdm845.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2018, The Linux Foundation. All rights reserved.
 */

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of_device.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/jack.h>
#include <sound/soc.h>
#include <uapi/linux/input-event-codes.h>
#include "common.h"
#include "qdsp6/q6afe.h"
#include "../codecs/rt5663.h"

#define DEFAULT_SAMPLE_RATE_48K		48000
#define DEFAULT_MCLK_RATE		24576000
#define TDM_BCLK_RATE		6144000
#define MI2S_BCLK_RATE		1536000
#define LEFT_SPK_TDM_TX_MASK    0x30
#define RIGHT_SPK_TDM_TX_MASK   0xC0
#define SPK_TDM_RX_MASK         0x03
#define NUM_TDM_SLOTS           8

struct sdm845_snd_data {
	struct snd_soc_jack jack;
	bool jack_setup;
	struct snd_soc_card *card;
	uint32_t pri_mi2s_clk_count;
	uint32_t sec_mi2s_clk_count;
	uint32_t quat_tdm_clk_count;
};

static unsigned int tdm_slot_offset[8] = {0, 4, 8, 12, 16, 20, 24, 28};

static int sdm845_tdm_snd_hw_params(struct snd_pcm_substream *substream,
					struct snd_pcm_hw_params *params)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	int ret = 0, j;
	int channels, slot_width;

	switch (params_format(params)) {
	case SNDRV_PCM_FORMAT_S16_LE:
		slot_width = 16;
		break;
	default:
		dev_err(rtd->dev, "%s: invalid param format 0x%x\n",
				__func__, params_format(params));
		return -EINVAL;
	}

	channels = params_channels(params);
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0, 0x3,
				8, slot_width);
		if (ret < 0) {
			dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n",
					__func__, ret);
			goto end;
		}

		ret = snd_soc_dai_set_channel_map(cpu_dai, 0, NULL,
				channels, tdm_slot_offset);
		if (ret < 0) {
			dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n",
					__func__, ret);
			goto end;
		}
	} else {
		ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0xf, 0,
				8, slot_width);
		if (ret < 0) {
			dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n",
					__func__, ret);
			goto end;
		}

		ret = snd_soc_dai_set_channel_map(cpu_dai, channels,
				tdm_slot_offset, 0, NULL);
		if (ret < 0) {
			dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n",
					__func__, ret);
			goto end;
		}
	}

	for (j = 0; j < rtd->num_codecs; j++) {
		struct snd_soc_dai *codec_dai = rtd->codec_dais[j];

		if (!strcmp(codec_dai->component->name_prefix, "Left")) {
			ret = snd_soc_dai_set_tdm_slot(
					codec_dai, LEFT_SPK_TDM_TX_MASK,
					SPK_TDM_RX_MASK, NUM_TDM_SLOTS,
					slot_width);
			if (ret < 0) {
				dev_err(rtd->dev,
					"DEV0 TDM slot err:%d\n", ret);
				return ret;
			}
		}

		if (!strcmp(codec_dai->component->name_prefix, "Right")) {
			ret = snd_soc_dai_set_tdm_slot(
					codec_dai, RIGHT_SPK_TDM_TX_MASK,
					SPK_TDM_RX_MASK, NUM_TDM_SLOTS,
					slot_width);
			if (ret < 0) {
				dev_err(rtd->dev,
					"DEV1 TDM slot err:%d\n", ret);
				return ret;
			}
		}
	}

end:
	return ret;
}

static int sdm845_snd_hw_params(struct snd_pcm_substream *substream,
					struct snd_pcm_hw_params *params)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	int ret = 0;

	switch (cpu_dai->id) {
	case PRIMARY_MI2S_RX:
	case PRIMARY_MI2S_TX:
		/*
		 * Use ASRC for internal clocks, as PLL rate isn't multiple
		 * of BCLK.
		 */
		rt5663_sel_asrc_clk_src(
			codec_dai->component,
			RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER,
			RT5663_CLK_SEL_I2S1_ASRC);
		ret = snd_soc_dai_set_sysclk(
			codec_dai, RT5663_SCLK_S_MCLK, DEFAULT_MCLK_RATE,
			SND_SOC_CLOCK_IN);
		if (ret < 0)
			dev_err(rtd->dev,
				"snd_soc_dai_set_sysclk err = %d\n", ret);
		break;
	case QUATERNARY_TDM_RX_0:
	case QUATERNARY_TDM_TX_0:
		ret = sdm845_tdm_snd_hw_params(substream, params);
		break;
	default:
		pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
		break;
	}
	return ret;
}

static void sdm845_jack_free(struct snd_jack *jack)
{
	struct snd_soc_component *component = jack->private_data;

	snd_soc_component_set_jack(component, NULL, NULL);
}

static int sdm845_dai_init(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_soc_component *component;
	struct snd_soc_card *card = rtd->card;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	struct sdm845_snd_data *pdata = snd_soc_card_get_drvdata(card);
	struct snd_jack *jack;
	int rval;

	if (!pdata->jack_setup) {
		rval = snd_soc_card_jack_new(card, "Headset Jack",
				SND_JACK_HEADSET |
				SND_JACK_HEADPHONE |
				SND_JACK_BTN_0 | SND_JACK_BTN_1 |
				SND_JACK_BTN_2 | SND_JACK_BTN_3,
				&pdata->jack, NULL, 0);

		if (rval < 0) {
			dev_err(card->dev, "Unable to add Headphone Jack\n");
			return rval;
		}

		jack = pdata->jack.jack;

		snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
		snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
		snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
		snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
		pdata->jack_setup = true;
	}

	switch (cpu_dai->id) {
	case PRIMARY_MI2S_RX:
		jack  = pdata->jack.jack;
		component = codec_dai->component;

		jack->private_data = component;
		jack->private_free = sdm845_jack_free;
		rval = snd_soc_component_set_jack(component,
						  &pdata->jack, NULL);
		if (rval != 0 && rval != -ENOTSUPP) {
			dev_warn(card->dev, "Failed to set jack: %d\n", rval);
			return rval;
		}
		break;
	default:
		break;
	}

	return 0;
}


static int sdm845_snd_startup(struct snd_pcm_substream *substream)
{
	unsigned int fmt = SND_SOC_DAIFMT_CBS_CFS;
	unsigned int codec_dai_fmt = SND_SOC_DAIFMT_CBS_CFS;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;
	struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	int j;
	int ret;

	switch (cpu_dai->id) {
	case PRIMARY_MI2S_RX:
	case PRIMARY_MI2S_TX:
		codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF;
		if (++(data->pri_mi2s_clk_count) == 1) {
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_MCLK_1,
				DEFAULT_MCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT,
				MI2S_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
		}
		snd_soc_dai_set_fmt(cpu_dai, fmt);
		snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
		break;

	case SECONDARY_MI2S_TX:
		codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_I2S;
		if (++(data->sec_mi2s_clk_count) == 1) {
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
				MI2S_BCLK_RATE,	SNDRV_PCM_STREAM_CAPTURE);
		}
		snd_soc_dai_set_fmt(cpu_dai, fmt);
		snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
		break;

	case QUATERNARY_TDM_RX_0:
	case QUATERNARY_TDM_TX_0:
		if (++(data->quat_tdm_clk_count) == 1) {
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT,
				TDM_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
		}

		codec_dai_fmt |= SND_SOC_DAIFMT_IB_NF | SND_SOC_DAIFMT_DSP_B;

		for (j = 0; j < rtd->num_codecs; j++) {
			codec_dai = rtd->codec_dais[j];

			if (!strcmp(codec_dai->component->name_prefix,
				    "Left")) {
				ret = snd_soc_dai_set_fmt(
						codec_dai, codec_dai_fmt);
				if (ret < 0) {
					dev_err(rtd->dev,
						"Left TDM fmt err:%d\n", ret);
					return ret;
				}
			}

			if (!strcmp(codec_dai->component->name_prefix,
				    "Right")) {
				ret = snd_soc_dai_set_fmt(
						codec_dai, codec_dai_fmt);
				if (ret < 0) {
					dev_err(rtd->dev,
						"Right TDM slot err:%d\n", ret);
					return ret;
				}
			}
		}
		break;

	default:
		pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
		break;
	}
	return 0;
}

static void  sdm845_snd_shutdown(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;
	struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

	switch (cpu_dai->id) {
	case PRIMARY_MI2S_RX:
	case PRIMARY_MI2S_TX:
		if (--(data->pri_mi2s_clk_count) == 0) {
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_MCLK_1,
				0, SNDRV_PCM_STREAM_PLAYBACK);
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT,
				0, SNDRV_PCM_STREAM_PLAYBACK);
		};
		break;

	case SECONDARY_MI2S_TX:
		if (--(data->sec_mi2s_clk_count) == 0) {
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
				0, SNDRV_PCM_STREAM_CAPTURE);
		}
		break;

	case QUATERNARY_TDM_RX_0:
	case QUATERNARY_TDM_TX_0:
		if (--(data->quat_tdm_clk_count) == 0) {
			snd_soc_dai_set_sysclk(cpu_dai,
				Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT,
				0, SNDRV_PCM_STREAM_PLAYBACK);
		}
		break;

	default:
		pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
		break;
	}
}

static const struct snd_soc_ops sdm845_be_ops = {
	.hw_params = sdm845_snd_hw_params,
	.startup = sdm845_snd_startup,
	.shutdown = sdm845_snd_shutdown,
};

static int sdm845_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
				struct snd_pcm_hw_params *params)
{
	struct snd_interval *rate = hw_param_interval(params,
					SNDRV_PCM_HW_PARAM_RATE);
	struct snd_interval *channels = hw_param_interval(params,
					SNDRV_PCM_HW_PARAM_CHANNELS);
	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);

	rate->min = rate->max = DEFAULT_SAMPLE_RATE_48K;
	channels->min = channels->max = 2;
	snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);

	return 0;
}

static const struct snd_soc_dapm_widget sdm845_snd_widgets[] = {
	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	SND_SOC_DAPM_MIC("Headset Mic", NULL),
	SND_SOC_DAPM_SPK("Left Spk", NULL),
	SND_SOC_DAPM_SPK("Right Spk", NULL),
	SND_SOC_DAPM_MIC("Int Mic", NULL),
};

static void sdm845_add_ops(struct snd_soc_card *card)
{
	struct snd_soc_dai_link *link;
	int i;

	for_each_card_prelinks(card, i, link) {
		if (link->no_pcm == 1) {
			link->ops = &sdm845_be_ops;
			link->be_hw_params_fixup = sdm845_be_hw_params_fixup;
		}
		link->init = sdm845_dai_init;
	}
}

static int sdm845_snd_platform_probe(struct platform_device *pdev)
{
	struct snd_soc_card *card;
	struct sdm845_snd_data *data;
	struct device *dev = &pdev->dev;
	int ret;

	card = kzalloc(sizeof(*card), GFP_KERNEL);
	if (!card)
		return -ENOMEM;

	/* Allocate the private data */
	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data) {
		ret = -ENOMEM;
		goto data_alloc_fail;
	}

	card->dapm_widgets = sdm845_snd_widgets;
	card->num_dapm_widgets = ARRAY_SIZE(sdm845_snd_widgets);
	card->dev = dev;
	dev_set_drvdata(dev, card);
	ret = qcom_snd_parse_of(card);
	if (ret) {
		dev_err(dev, "Error parsing OF data\n");
		goto parse_dt_fail;
	}

	data->card = card;
	snd_soc_card_set_drvdata(card, data);

	sdm845_add_ops(card);
	ret = snd_soc_register_card(card);
	if (ret) {
		dev_err(dev, "Sound card registration failed\n");
		goto register_card_fail;
	}
	return ret;

register_card_fail:
	kfree(card->dai_link);
parse_dt_fail:
	kfree(data);
data_alloc_fail:
	kfree(card);
	return ret;
}

static int sdm845_snd_platform_remove(struct platform_device *pdev)
{
	struct snd_soc_card *card = dev_get_drvdata(&pdev->dev);
	struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);

	snd_soc_unregister_card(card);
	kfree(card->dai_link);
	kfree(data);
	kfree(card);
	return 0;
}

static const struct of_device_id sdm845_snd_device_id[]  = {
	{ .compatible = "qcom,sdm845-sndcard" },
	{},
};
MODULE_DEVICE_TABLE(of, sdm845_snd_device_id);

static struct platform_driver sdm845_snd_driver = {
	.probe = sdm845_snd_platform_probe,
	.remove = sdm845_snd_platform_remove,
	.driver = {
		.name = "msm-snd-sdm845",
		.of_match_table = sdm845_snd_device_id,
	},
};
module_platform_driver(sdm845_snd_driver);

MODULE_DESCRIPTION("sdm845 ASoC Machine Driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
6b1687bf R	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2018, The Linux Foundation. All rights reserved.
	4	*/
	5
	6	#include <linux/module.h>
	7	#include <linux/platform_device.h>
6b1687bf	8	#include <linux/of_device.h>
09b38200	9	#include <sound/core.h>
6b1687bf R	10	#include <sound/pcm.h>
6b1687bf R	11	#include <sound/pcm_params.h>
80e733fd	12	#include <sound/jack.h>
09b38200	13	#include <sound/soc.h>
80e733fd	14	#include <uapi/linux/input-event-codes.h>
6b1687bf R	15	#include "common.h"
6b1687bf R	16	#include "qdsp6/q6afe.h"
ce55698d	17	#include "../codecs/rt5663.h"
6b1687bf R	18
	19	#define DEFAULT_SAMPLE_RATE_48K 48000
	20	#define DEFAULT_MCLK_RATE 24576000
a1849b7d R	21	#define TDM_BCLK_RATE 6144000
a1849b7d R	22	#define MI2S_BCLK_RATE 1536000
09b38200 CYC	23	#define LEFT_SPK_TDM_TX_MASK 0x30
	24	#define RIGHT_SPK_TDM_TX_MASK 0xC0
	25	#define SPK_TDM_RX_MASK 0x03
	26	#define NUM_TDM_SLOTS 8
6b1687bf R	27
6b1687bf R	28	struct sdm845_snd_data {
80e733fd CYC	29	struct snd_soc_jack jack;
80e733fd CYC	30	bool jack_setup;
6b1687bf R	31	struct snd_soc_card *card;
6b1687bf R	32	uint32_t pri_mi2s_clk_count;
992e75b3	33	uint32_t sec_mi2s_clk_count;
6b1687bf R	34	uint32_t quat_tdm_clk_count;
	35	};
	36
	37	static unsigned int tdm_slot_offset[8] = {0, 4, 8, 12, 16, 20, 24, 28};
	38
	39	static int sdm845_tdm_snd_hw_params(struct snd_pcm_substream *substream,
	40	struct snd_pcm_hw_params *params)
	41	{
	42	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	43	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
09b38200	44	int ret = 0, j;
6b1687bf R	45	int channels, slot_width;
	46
	47	switch (params_format(params)) {
	48	case SNDRV_PCM_FORMAT_S16_LE:
a1849b7d	49	slot_width = 16;
6b1687bf R	50	break;
	51	default:
	52	dev_err(rtd->dev, "%s: invalid param format 0x%x\n",
	53	__func__, params_format(params));
	54	return -EINVAL;
	55	}
	56
	57	channels = params_channels(params);
	58	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	59	ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0, 0x3,
	60	8, slot_width);
	61	if (ret < 0) {
	62	dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n",
	63	__func__, ret);
	64	goto end;
	65	}
	66
	67	ret = snd_soc_dai_set_channel_map(cpu_dai, 0, NULL,
	68	channels, tdm_slot_offset);
	69	if (ret < 0) {
	70	dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n",
	71	__func__, ret);
	72	goto end;
	73	}
	74	} else {
	75	ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0xf, 0,
	76	8, slot_width);
	77	if (ret < 0) {
	78	dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n",
	79	__func__, ret);
	80	goto end;
	81	}
	82
	83	ret = snd_soc_dai_set_channel_map(cpu_dai, channels,
	84	tdm_slot_offset, 0, NULL);
	85	if (ret < 0) {
	86	dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n",
	87	__func__, ret);
	88	goto end;
	89	}
	90	}
09b38200 CYC	91
	92	for (j = 0; j < rtd->num_codecs; j++) {
	93	struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
	94
	95	if (!strcmp(codec_dai->component->name_prefix, "Left")) {
	96	ret = snd_soc_dai_set_tdm_slot(
	97	codec_dai, LEFT_SPK_TDM_TX_MASK,
	98	SPK_TDM_RX_MASK, NUM_TDM_SLOTS,
	99	slot_width);
	100	if (ret < 0) {
	101	dev_err(rtd->dev,
	102	"DEV0 TDM slot err:%d\n", ret);
	103	return ret;
	104	}
	105	}
	106
	107	if (!strcmp(codec_dai->component->name_prefix, "Right")) {
	108	ret = snd_soc_dai_set_tdm_slot(
	109	codec_dai, RIGHT_SPK_TDM_TX_MASK,
	110	SPK_TDM_RX_MASK, NUM_TDM_SLOTS,
	111	slot_width);
	112	if (ret < 0) {
	113	dev_err(rtd->dev,
	114	"DEV1 TDM slot err:%d\n", ret);
	115	return ret;
	116	}
	117	}
	118	}
	119
6b1687bf R	120	end:
	121	return ret;
	122	}
	123
	124	static int sdm845_snd_hw_params(struct snd_pcm_substream *substream,
	125	struct snd_pcm_hw_params *params)
	126	{
	127	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	128	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
ce55698d	129	struct snd_soc_dai *codec_dai = rtd->codec_dai;
6b1687bf R	130	int ret = 0;
	131
	132	switch (cpu_dai->id) {
ce55698d CYC	133	case PRIMARY_MI2S_RX:
	134	case PRIMARY_MI2S_TX:
	135	/*
	136	* Use ASRC for internal clocks, as PLL rate isn't multiple
	137	* of BCLK.
	138	*/
	139	rt5663_sel_asrc_clk_src(
	140	codec_dai->component,
	141	RT5663_DA_STEREO_FILTER \| RT5663_AD_STEREO_FILTER,
	142	RT5663_CLK_SEL_I2S1_ASRC);
	143	ret = snd_soc_dai_set_sysclk(
	144	codec_dai, RT5663_SCLK_S_MCLK, DEFAULT_MCLK_RATE,
	145	SND_SOC_CLOCK_IN);
	146	if (ret < 0)
	147	dev_err(rtd->dev,
	148	"snd_soc_dai_set_sysclk err = %d\n", ret);
	149	break;
6b1687bf R	150	case QUATERNARY_TDM_RX_0:
	151	case QUATERNARY_TDM_TX_0:
	152	ret = sdm845_tdm_snd_hw_params(substream, params);
	153	break;
	154	default:
	155	pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
	156	break;
	157	}
	158	return ret;
	159	}
	160
2998369f R	161	static void sdm845_jack_free(struct snd_jack *jack)
	162	{
	163	struct snd_soc_component *component = jack->private_data;
	164
	165	snd_soc_component_set_jack(component, NULL, NULL);
	166	}
	167
80e733fd CYC	168	static int sdm845_dai_init(struct snd_soc_pcm_runtime *rtd)
	169	{
	170	struct snd_soc_component *component;
80e733fd	171	struct snd_soc_card *card = rtd->card;
2998369f R	172	struct snd_soc_dai *codec_dai = rtd->codec_dai;
2998369f R	173	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
80e733fd	174	struct sdm845_snd_data *pdata = snd_soc_card_get_drvdata(card);
2998369f R	175	struct snd_jack *jack;
2998369f R	176	int rval;
80e733fd CYC	177
80e733fd CYC	178	if (!pdata->jack_setup) {
80e733fd CYC	179	rval = snd_soc_card_jack_new(card, "Headset Jack",
	180	SND_JACK_HEADSET \|
	181	SND_JACK_HEADPHONE \|
	182	SND_JACK_BTN_0 \| SND_JACK_BTN_1 \|
	183	SND_JACK_BTN_2 \| SND_JACK_BTN_3,
	184	&pdata->jack, NULL, 0);
	185
	186	if (rval < 0) {
	187	dev_err(card->dev, "Unable to add Headphone Jack\n");
	188	return rval;
	189	}
	190
	191	jack = pdata->jack.jack;
	192
	193	snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
	194	snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
	195	snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
	196	snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
	197	pdata->jack_setup = true;
	198	}
	199
2998369f R	200	switch (cpu_dai->id) {
	201	case PRIMARY_MI2S_RX:
	202	jack = pdata->jack.jack;
	203	component = codec_dai->component;
80e733fd	204
2998369f R	205	jack->private_data = component;
	206	jack->private_free = sdm845_jack_free;
	207	rval = snd_soc_component_set_jack(component,
	208	&pdata->jack, NULL);
80e733fd CYC	209	if (rval != 0 && rval != -ENOTSUPP) {
	210	dev_warn(card->dev, "Failed to set jack: %d\n", rval);
	211	return rval;
	212	}
2998369f R	213	break;
	214	default:
	215	break;
80e733fd CYC	216	}
	217
	218	return 0;
	219	}
	220
	221
6b1687bf R	222	static int sdm845_snd_startup(struct snd_pcm_substream *substream)
	223	{
	224	unsigned int fmt = SND_SOC_DAIFMT_CBS_CFS;
09b38200	225	unsigned int codec_dai_fmt = SND_SOC_DAIFMT_CBS_CFS;
6b1687bf R	226	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	227	struct snd_soc_card *card = rtd->card;
	228	struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
	229	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
09b38200 CYC	230	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	231	int j;
	232	int ret;
6b1687bf R	233
	234	switch (cpu_dai->id) {
	235	case PRIMARY_MI2S_RX:
	236	case PRIMARY_MI2S_TX:
ce55698d	237	codec_dai_fmt \|= SND_SOC_DAIFMT_NB_NF;
6b1687bf R	238	if (++(data->pri_mi2s_clk_count) == 1) {
	239	snd_soc_dai_set_sysclk(cpu_dai,
	240	Q6AFE_LPASS_CLK_ID_MCLK_1,
	241	DEFAULT_MCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
	242	snd_soc_dai_set_sysclk(cpu_dai,
	243	Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT,
a1849b7d	244	MI2S_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
6b1687bf R	245	}
6b1687bf R	246	snd_soc_dai_set_fmt(cpu_dai, fmt);
ce55698d	247	snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
6b1687bf R	248	break;
6b1687bf R	249
992e75b3	250	case SECONDARY_MI2S_TX:
9019ab10	251	codec_dai_fmt \|= SND_SOC_DAIFMT_NB_NF \| SND_SOC_DAIFMT_I2S;
992e75b3 R	252	if (++(data->sec_mi2s_clk_count) == 1) {
	253	snd_soc_dai_set_sysclk(cpu_dai,
	254	Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
	255	MI2S_BCLK_RATE, SNDRV_PCM_STREAM_CAPTURE);
	256	}
	257	snd_soc_dai_set_fmt(cpu_dai, fmt);
9019ab10	258	snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
992e75b3 R	259	break;
992e75b3 R	260
6b1687bf R	261	case QUATERNARY_TDM_RX_0:
	262	case QUATERNARY_TDM_TX_0:
	263	if (++(data->quat_tdm_clk_count) == 1) {
	264	snd_soc_dai_set_sysclk(cpu_dai,
	265	Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT,
a1849b7d	266	TDM_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
6b1687bf	267	}
09b38200 CYC	268
	269	codec_dai_fmt \|= SND_SOC_DAIFMT_IB_NF \| SND_SOC_DAIFMT_DSP_B;
	270
	271	for (j = 0; j < rtd->num_codecs; j++) {
	272	codec_dai = rtd->codec_dais[j];
	273
	274	if (!strcmp(codec_dai->component->name_prefix,
	275	"Left")) {
	276	ret = snd_soc_dai_set_fmt(
	277	codec_dai, codec_dai_fmt);
	278	if (ret < 0) {
	279	dev_err(rtd->dev,
	280	"Left TDM fmt err:%d\n", ret);
	281	return ret;
	282	}
	283	}
	284
	285	if (!strcmp(codec_dai->component->name_prefix,
	286	"Right")) {
	287	ret = snd_soc_dai_set_fmt(
	288	codec_dai, codec_dai_fmt);
	289	if (ret < 0) {
	290	dev_err(rtd->dev,
	291	"Right TDM slot err:%d\n", ret);
	292	return ret;
	293	}
	294	}
	295	}
6b1687bf R	296	break;
	297
	298	default:
	299	pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
	300	break;
	301	}
	302	return 0;
	303	}
	304
	305	static void sdm845_snd_shutdown(struct snd_pcm_substream *substream)
	306	{
	307	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	308	struct snd_soc_card *card = rtd->card;
	309	struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
	310	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	311
	312	switch (cpu_dai->id) {
	313	case PRIMARY_MI2S_RX:
	314	case PRIMARY_MI2S_TX:
	315	if (--(data->pri_mi2s_clk_count) == 0) {
	316	snd_soc_dai_set_sysclk(cpu_dai,
	317	Q6AFE_LPASS_CLK_ID_MCLK_1,
	318	0, SNDRV_PCM_STREAM_PLAYBACK);
	319	snd_soc_dai_set_sysclk(cpu_dai,
	320	Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT,
	321	0, SNDRV_PCM_STREAM_PLAYBACK);
	322	};
	323	break;
	324
992e75b3 R	325	case SECONDARY_MI2S_TX:
	326	if (--(data->sec_mi2s_clk_count) == 0) {
	327	snd_soc_dai_set_sysclk(cpu_dai,
	328	Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
	329	0, SNDRV_PCM_STREAM_CAPTURE);
	330	}
	331	break;
	332
6b1687bf R	333	case QUATERNARY_TDM_RX_0:
	334	case QUATERNARY_TDM_TX_0:
	335	if (--(data->quat_tdm_clk_count) == 0) {
	336	snd_soc_dai_set_sysclk(cpu_dai,
	337	Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT,
	338	0, SNDRV_PCM_STREAM_PLAYBACK);
	339	}
	340	break;
	341
	342	default:
	343	pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
	344	break;
	345	}
	346	}
	347
ff60005e	348	static const struct snd_soc_ops sdm845_be_ops = {
6b1687bf R	349	.hw_params = sdm845_snd_hw_params,
	350	.startup = sdm845_snd_startup,
	351	.shutdown = sdm845_snd_shutdown,
	352	};
	353
	354	static int sdm845_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
	355	struct snd_pcm_hw_params *params)
	356	{
	357	struct snd_interval *rate = hw_param_interval(params,
	358	SNDRV_PCM_HW_PARAM_RATE);
	359	struct snd_interval *channels = hw_param_interval(params,
	360	SNDRV_PCM_HW_PARAM_CHANNELS);
	361	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
	362
	363	rate->min = rate->max = DEFAULT_SAMPLE_RATE_48K;
	364	channels->min = channels->max = 2;
	365	snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
	366
	367	return 0;
	368	}
	369
7f1806eb CYC	370	static const struct snd_soc_dapm_widget sdm845_snd_widgets[] = {
	371	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	372	SND_SOC_DAPM_MIC("Headset Mic", NULL),
	373	SND_SOC_DAPM_SPK("Left Spk", NULL),
	374	SND_SOC_DAPM_SPK("Right Spk", NULL),
	375	SND_SOC_DAPM_MIC("Int Mic", NULL),
	376	};
	377
80e733fd	378	static void sdm845_add_ops(struct snd_soc_card *card)
6b1687bf	379	{
7fe072b4 KM	380	struct snd_soc_dai_link *link;
7fe072b4 KM	381	int i;
6b1687bf	382
7fe072b4	383	for_each_card_prelinks(card, i, link) {
6b1687bf R	384	if (link->no_pcm == 1) {
	385	link->ops = &sdm845_be_ops;
	386	link->be_hw_params_fixup = sdm845_be_hw_params_fixup;
	387	}
80e733fd	388	link->init = sdm845_dai_init;
6b1687bf R	389	}
	390	}
	391
	392	static int sdm845_snd_platform_probe(struct platform_device *pdev)
	393	{
	394	struct snd_soc_card *card;
	395	struct sdm845_snd_data *data;
	396	struct device *dev = &pdev->dev;
	397	int ret;
	398
	399	card = kzalloc(sizeof(*card), GFP_KERNEL);
	400	if (!card)
	401	return -ENOMEM;
	402
	403	/* Allocate the private data */
	404	data = kzalloc(sizeof(*data), GFP_KERNEL);
8530ebf1 GS	405	if (!data) {
	406	ret = -ENOMEM;
	407	goto data_alloc_fail;
	408	}
6b1687bf	409
7f1806eb CYC	410	card->dapm_widgets = sdm845_snd_widgets;
7f1806eb CYC	411	card->num_dapm_widgets = ARRAY_SIZE(sdm845_snd_widgets);
6b1687bf	412	card->dev = dev;
6b1687bf R	413	dev_set_drvdata(dev, card);
	414	ret = qcom_snd_parse_of(card);
	415	if (ret) {
	416	dev_err(dev, "Error parsing OF data\n");
	417	goto parse_dt_fail;
	418	}
	419
	420	data->card = card;
	421	snd_soc_card_set_drvdata(card, data);
	422
80e733fd	423	sdm845_add_ops(card);
6b1687bf R	424	ret = snd_soc_register_card(card);
	425	if (ret) {
	426	dev_err(dev, "Sound card registration failed\n");
	427	goto register_card_fail;
	428	}
	429	return ret;
	430
	431	register_card_fail:
	432	kfree(card->dai_link);
	433	parse_dt_fail:
	434	kfree(data);
8530ebf1	435	data_alloc_fail:
6b1687bf R	436	kfree(card);
	437	return ret;
	438	}
	439
	440	static int sdm845_snd_platform_remove(struct platform_device *pdev)
	441	{
	442	struct snd_soc_card *card = dev_get_drvdata(&pdev->dev);
	443	struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card);
	444
6b1687bf R	445	snd_soc_unregister_card(card);
	446	kfree(card->dai_link);
	447	kfree(data);
	448	kfree(card);
	449	return 0;
	450	}
	451
	452	static const struct of_device_id sdm845_snd_device_id[] = {
	453	{ .compatible = "qcom,sdm845-sndcard" },
	454	{},
	455	};
	456	MODULE_DEVICE_TABLE(of, sdm845_snd_device_id);
	457
	458	static struct platform_driver sdm845_snd_driver = {
	459	.probe = sdm845_snd_platform_probe,
	460	.remove = sdm845_snd_platform_remove,
	461	.driver = {
	462	.name = "msm-snd-sdm845",
	463	.of_match_table = sdm845_snd_device_id,
	464	},
	465	};
	466	module_platform_driver(sdm845_snd_driver);
	467
	468	MODULE_DESCRIPTION("sdm845 ASoC Machine Driver");
	469	MODULE_LICENSE("GPL v2");