[mirror_ubuntu-jammy-kernel.git] / sound / soc / amd / acp-da7219-max98357a.c

/*
 * Machine driver for AMD ACP Audio engine using DA7219 & MAX98357 codec
 *
 * Copyright 2017 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 */

#include <sound/core.h>
#include <sound/soc.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc-dapm.h>
#include <sound/jack.h>
#include <linux/clk.h>
#include <linux/gpio.h>
#include <linux/module.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/driver.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/acpi.h>

#include "acp.h"
#include "../codecs/da7219.h"
#include "../codecs/da7219-aad.h"

#define CZ_PLAT_CLK 48000000
#define DUAL_CHANNEL		2

static struct snd_soc_jack cz_jack;
static struct clk *da7219_dai_wclk;
static struct clk *da7219_dai_bclk;
extern bool bt_uart_enable;

static int cz_da7219_init(struct snd_soc_pcm_runtime *rtd)
{
	int ret;
	struct snd_soc_card *card = rtd->card;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	struct snd_soc_component *component = codec_dai->component;

	dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name);

	ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK,
				     CZ_PLAT_CLK, SND_SOC_CLOCK_IN);
	if (ret < 0) {
		dev_err(rtd->dev, "can't set codec sysclk: %d\n", ret);
		return ret;
	}

	ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_PLL,
				  CZ_PLAT_CLK, DA7219_PLL_FREQ_OUT_98304);
	if (ret < 0) {
		dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
		return ret;
	}

	da7219_dai_wclk = clk_get(component->dev, "da7219-dai-wclk");
	da7219_dai_bclk = clk_get(component->dev, "da7219-dai-bclk");

	ret = snd_soc_card_jack_new(card, "Headset Jack",
				SND_JACK_HEADSET | SND_JACK_LINEOUT |
				SND_JACK_BTN_0 | SND_JACK_BTN_1 |
				SND_JACK_BTN_2 | SND_JACK_BTN_3,
				&cz_jack, NULL, 0);
	if (ret) {
		dev_err(card->dev, "HP jack creation failed %d\n", ret);
		return ret;
	}

	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_3, KEY_VOICECOMMAND);

	da7219_aad_jack_det(component, &cz_jack);

	return 0;
}

static int da7219_clk_enable(struct snd_pcm_substream *substream)
{
	int ret = 0;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;

	/*
	 * Set wclk to 48000 because the rate constraint of this driver is
	 * 48000. ADAU7002 spec: "The ADAU7002 requires a BCLK rate that is
	 * minimum of 64x the LRCLK sample rate." DA7219 is the only clk
	 * source so for all codecs we have to limit bclk to 64X lrclk.
	 */
	clk_set_rate(da7219_dai_wclk, 48000);
	clk_set_rate(da7219_dai_bclk, 48000 * 64);
	ret = clk_prepare_enable(da7219_dai_bclk);
	if (ret < 0) {
		dev_err(rtd->dev, "can't enable master clock %d\n", ret);
		return ret;
	}

	return ret;
}

static void da7219_clk_disable(void)
{
	clk_disable_unprepare(da7219_dai_bclk);
}

static const unsigned int channels[] = {
	DUAL_CHANNEL,
};

static const unsigned int rates[] = {
	48000,
};

static const struct snd_pcm_hw_constraint_list constraints_rates = {
	.count = ARRAY_SIZE(rates),
	.list  = rates,
	.mask = 0,
};

static const struct snd_pcm_hw_constraint_list constraints_channels = {
	.count = ARRAY_SIZE(channels),
	.list = channels,
	.mask = 0,
};

static int cz_da7219_play_startup(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;
	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);

	/*
	 * On this platform for PCM device we support stereo
	 */

	runtime->hw.channels_max = DUAL_CHANNEL;
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
				   &constraints_channels);
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
				   &constraints_rates);

	machine->play_i2s_instance = I2S_SP_INSTANCE;
	return da7219_clk_enable(substream);
}

static int cz_da7219_cap_startup(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;
	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);

	/*
	 * On this platform for PCM device we support stereo
	 */

	runtime->hw.channels_max = DUAL_CHANNEL;
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
				   &constraints_channels);
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
				   &constraints_rates);

	machine->cap_i2s_instance = I2S_SP_INSTANCE;
	machine->capture_channel = CAP_CHANNEL1;
	return da7219_clk_enable(substream);
}

static int cz_max_startup(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;
	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);

	/*
	 * On this platform for PCM device we support stereo
	 */

	runtime->hw.channels_max = DUAL_CHANNEL;
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
				   &constraints_channels);
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
				   &constraints_rates);

	machine->play_i2s_instance = I2S_BT_INSTANCE;
	return da7219_clk_enable(substream);
}

static int cz_dmic0_startup(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;
	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);

	/*
	 * On this platform for PCM device we support stereo
	 */

	runtime->hw.channels_max = DUAL_CHANNEL;
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
				   &constraints_channels);
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
				   &constraints_rates);

	machine->cap_i2s_instance = I2S_BT_INSTANCE;
	return da7219_clk_enable(substream);
}

static int cz_dmic1_startup(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_card *card = rtd->card;
	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);

	/*
	 * On this platform for PCM device we support stereo
	 */

	runtime->hw.channels_max = DUAL_CHANNEL;
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
				   &constraints_channels);
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
				   &constraints_rates);

	machine->cap_i2s_instance = I2S_SP_INSTANCE;
	machine->capture_channel = CAP_CHANNEL0;
	return da7219_clk_enable(substream);
}

static void cz_da7219_shutdown(struct snd_pcm_substream *substream)
{
	da7219_clk_disable();
}

static const struct snd_soc_ops cz_da7219_play_ops = {
	.startup = cz_da7219_play_startup,
	.shutdown = cz_da7219_shutdown,
};

static const struct snd_soc_ops cz_da7219_cap_ops = {
	.startup = cz_da7219_cap_startup,
	.shutdown = cz_da7219_shutdown,
};

static const struct snd_soc_ops cz_max_play_ops = {
	.startup = cz_max_startup,
	.shutdown = cz_da7219_shutdown,
};

static const struct snd_soc_ops cz_dmic0_cap_ops = {
	.startup = cz_dmic0_startup,
	.shutdown = cz_da7219_shutdown,
};

static const struct snd_soc_ops cz_dmic1_cap_ops = {
	.startup = cz_dmic1_startup,
	.shutdown = cz_da7219_shutdown,
};

SND_SOC_DAILINK_DEF(designware1,
	DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.1.auto")));
SND_SOC_DAILINK_DEF(designware2,
	DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.2.auto")));
SND_SOC_DAILINK_DEF(designware3,
	DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.3.auto")));

SND_SOC_DAILINK_DEF(dlgs,
	DAILINK_COMP_ARRAY(COMP_CODEC("i2c-DLGS7219:00", "da7219-hifi")));
SND_SOC_DAILINK_DEF(mx,
	DAILINK_COMP_ARRAY(COMP_CODEC("MX98357A:00", "HiFi")));
SND_SOC_DAILINK_DEF(adau,
	DAILINK_COMP_ARRAY(COMP_CODEC("ADAU7002:00", "adau7002-hifi")));

SND_SOC_DAILINK_DEF(platform,
	DAILINK_COMP_ARRAY(COMP_PLATFORM("acp_audio_dma.0.auto")));

static struct snd_soc_dai_link cz_dai_7219_98357[] = {
	{
		.name = "amd-da7219-play",
		.stream_name = "Playback",
		.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
				| SND_SOC_DAIFMT_CBM_CFM,
		.init = cz_da7219_init,
		.dpcm_playback = 1,
		.ops = &cz_da7219_play_ops,
		SND_SOC_DAILINK_REG(designware1, dlgs, platform),
	},
	{
		.name = "amd-da7219-cap",
		.stream_name = "Capture",
		.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
				| SND_SOC_DAIFMT_CBM_CFM,
		.dpcm_capture = 1,
		.ops = &cz_da7219_cap_ops,
		SND_SOC_DAILINK_REG(designware2, dlgs, platform),
	},
	{
		.name = "amd-max98357-play",
		.stream_name = "HiFi Playback",
		.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
				| SND_SOC_DAIFMT_CBM_CFM,
		.dpcm_playback = 1,
		.ops = &cz_max_play_ops,
		SND_SOC_DAILINK_REG(designware3, mx, platform),
	},
	{
		/* C panel DMIC */
		.name = "dmic0",
		.stream_name = "DMIC0 Capture",
		.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
				| SND_SOC_DAIFMT_CBM_CFM,
		.dpcm_capture = 1,
		.ops = &cz_dmic0_cap_ops,
		SND_SOC_DAILINK_REG(designware3, adau, platform),
	},
	{
		/* A/B panel DMIC */
		.name = "dmic1",
		.stream_name = "DMIC1 Capture",
		.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
				| SND_SOC_DAIFMT_CBM_CFM,
		.dpcm_capture = 1,
		.ops = &cz_dmic1_cap_ops,
		SND_SOC_DAILINK_REG(designware2, adau, platform),
	},
};

static const struct snd_soc_dapm_widget cz_widgets[] = {
	SND_SOC_DAPM_HP("Headphones", NULL),
	SND_SOC_DAPM_SPK("Speakers", NULL),
	SND_SOC_DAPM_MIC("Headset Mic", NULL),
	SND_SOC_DAPM_MIC("Int Mic", NULL),
};

static const struct snd_soc_dapm_route cz_audio_route[] = {
	{"Headphones", NULL, "HPL"},
	{"Headphones", NULL, "HPR"},
	{"MIC", NULL, "Headset Mic"},
	{"Speakers", NULL, "Speaker"},
	{"PDM_DAT", NULL, "Int Mic"},
};

static const struct snd_kcontrol_new cz_mc_controls[] = {
	SOC_DAPM_PIN_SWITCH("Headphones"),
	SOC_DAPM_PIN_SWITCH("Speakers"),
	SOC_DAPM_PIN_SWITCH("Headset Mic"),
	SOC_DAPM_PIN_SWITCH("Int Mic"),
};

static struct snd_soc_card cz_card = {
	.name = "acpd7219m98357",
	.owner = THIS_MODULE,
	.dai_link = cz_dai_7219_98357,
	.num_links = ARRAY_SIZE(cz_dai_7219_98357),
	.dapm_widgets = cz_widgets,
	.num_dapm_widgets = ARRAY_SIZE(cz_widgets),
	.dapm_routes = cz_audio_route,
	.num_dapm_routes = ARRAY_SIZE(cz_audio_route),
	.controls = cz_mc_controls,
	.num_controls = ARRAY_SIZE(cz_mc_controls),
};

static struct regulator_consumer_supply acp_da7219_supplies[] = {
	REGULATOR_SUPPLY("VDD", "i2c-DLGS7219:00"),
	REGULATOR_SUPPLY("VDDMIC", "i2c-DLGS7219:00"),
	REGULATOR_SUPPLY("VDDIO", "i2c-DLGS7219:00"),
	REGULATOR_SUPPLY("IOVDD", "ADAU7002:00"),
};

static struct regulator_init_data acp_da7219_data = {
	.constraints = {
		.always_on = 1,
	},
	.num_consumer_supplies = ARRAY_SIZE(acp_da7219_supplies),
	.consumer_supplies = acp_da7219_supplies,
};

static struct regulator_config acp_da7219_cfg = {
	.init_data = &acp_da7219_data,
};

static struct regulator_ops acp_da7219_ops = {
};

static const struct regulator_desc acp_da7219_desc = {
	.name = "reg-fixed-1.8V",
	.type = REGULATOR_VOLTAGE,
	.owner = THIS_MODULE,
	.ops = &acp_da7219_ops,
	.fixed_uV = 1800000, /* 1.8V */
	.n_voltages = 1,
};

static int cz_probe(struct platform_device *pdev)
{
	int ret;
	struct snd_soc_card *card;
	struct acp_platform_info *machine;
	struct regulator_dev *rdev;

	acp_da7219_cfg.dev = &pdev->dev;
	rdev = devm_regulator_register(&pdev->dev, &acp_da7219_desc,
				       &acp_da7219_cfg);
	if (IS_ERR(rdev)) {
		dev_err(&pdev->dev, "Failed to register regulator: %d\n",
			(int)PTR_ERR(rdev));
		return -EINVAL;
	}

	machine = devm_kzalloc(&pdev->dev, sizeof(struct acp_platform_info),
			       GFP_KERNEL);
	if (!machine)
		return -ENOMEM;
	card = &cz_card;
	cz_card.dev = &pdev->dev;
	platform_set_drvdata(pdev, card);
	snd_soc_card_set_drvdata(card, machine);
	ret = devm_snd_soc_register_card(&pdev->dev, &cz_card);
	if (ret) {
		dev_err(&pdev->dev,
				"devm_snd_soc_register_card(%s) failed: %d\n",
				cz_card.name, ret);
		return ret;
	}
	bt_uart_enable = !device_property_read_bool(&pdev->dev,
						    "bt-pad-enable");
	return 0;
}

static const struct acpi_device_id cz_audio_acpi_match[] = {
	{ "AMD7219", 0 },
	{},
};
MODULE_DEVICE_TABLE(acpi, cz_audio_acpi_match);

static struct platform_driver cz_pcm_driver = {
	.driver = {
		.name = "cz-da7219-max98357a",
		.acpi_match_table = ACPI_PTR(cz_audio_acpi_match),
		.pm = &snd_soc_pm_ops,
	},
	.probe = cz_probe,
};

module_platform_driver(cz_pcm_driver);

MODULE_AUTHOR("akshu.agrawal@amd.com");
MODULE_DESCRIPTION("DA7219 & MAX98357A audio support");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
608a300f AA	1	/*
	2	* Machine driver for AMD ACP Audio engine using DA7219 & MAX98357 codec
	3	*
	4	* Copyright 2017 Advanced Micro Devices, Inc.
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a
	7	* copy of this software and associated documentation files (the "Software"),
	8	* to deal in the Software without restriction, including without limitation
	9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	10	* and/or sell copies of the Software, and to permit persons to whom the
	11	* Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
	20	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	21	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	22	* OTHER DEALINGS IN THE SOFTWARE.
	23	*
	24	*/
	25
	26	#include <sound/core.h>
	27	#include <sound/soc.h>
	28	#include <sound/pcm.h>
	29	#include <sound/pcm_params.h>
	30	#include <sound/soc-dapm.h>
	31	#include <sound/jack.h>
c88d3115	32	#include <linux/clk.h>
608a300f AA	33	#include <linux/gpio.h>
608a300f AA	34	#include <linux/module.h>
c183fec1 AA	35	#include <linux/regulator/machine.h>
c183fec1 AA	36	#include <linux/regulator/driver.h>
608a300f	37	#include <linux/i2c.h>
923859e3	38	#include <linux/input.h>
608a300f AA	39	#include <linux/acpi.h>
608a300f AA	40
ccfbb4f5	41	#include "acp.h"
608a300f AA	42	#include "../codecs/da7219.h"
	43	#include "../codecs/da7219-aad.h"
	44
a1b1e988	45	#define CZ_PLAT_CLK 48000000
608a300f AA	46	#define DUAL_CHANNEL 2
	47
	48	static struct snd_soc_jack cz_jack;
bb24a31e AA	49	static struct clk *da7219_dai_wclk;
bb24a31e AA	50	static struct clk *da7219_dai_bclk;
eddb6084	51	extern bool bt_uart_enable;
608a300f AA	52
	53	static int cz_da7219_init(struct snd_soc_pcm_runtime *rtd)
	54	{
	55	int ret;
	56	struct snd_soc_card *card = rtd->card;
608a300f	57	struct snd_soc_dai *codec_dai = rtd->codec_dai;
9a60cde2	58	struct snd_soc_component *component = codec_dai->component;
608a300f AA	59
	60	dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name);
	61
	62	ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK,
	63	CZ_PLAT_CLK, SND_SOC_CLOCK_IN);
	64	if (ret < 0) {
	65	dev_err(rtd->dev, "can't set codec sysclk: %d\n", ret);
	66	return ret;
	67	}
	68
	69	ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_PLL,
6e554074	70	CZ_PLAT_CLK, DA7219_PLL_FREQ_OUT_98304);
608a300f AA	71	if (ret < 0) {
	72	dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
	73	return ret;
	74	}
	75
bb24a31e AA	76	da7219_dai_wclk = clk_get(component->dev, "da7219-dai-wclk");
bb24a31e AA	77	da7219_dai_bclk = clk_get(component->dev, "da7219-dai-bclk");
c88d3115	78
608a300f	79	ret = snd_soc_card_jack_new(card, "Headset Jack",
2657c6a9	80	SND_JACK_HEADSET \| SND_JACK_LINEOUT \|
608a300f AA	81	SND_JACK_BTN_0 \| SND_JACK_BTN_1 \|
	82	SND_JACK_BTN_2 \| SND_JACK_BTN_3,
	83	&cz_jack, NULL, 0);
	84	if (ret) {
	85	dev_err(card->dev, "HP jack creation failed %d\n", ret);
	86	return ret;
	87	}
	88
923859e3 AA	89	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
	90	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
	91	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
	92	snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_3, KEY_VOICECOMMAND);
	93
9a60cde2	94	da7219_aad_jack_det(component, &cz_jack);
608a300f AA	95
	96	return 0;
	97	}
	98
756ae8f2	99	static int da7219_clk_enable(struct snd_pcm_substream *substream)
c88d3115 AA	100	{
	101	int ret = 0;
	102	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	103
756ae8f2 YHH	104	/*
	105	* Set wclk to 48000 because the rate constraint of this driver is
	106	* 48000. ADAU7002 spec: "The ADAU7002 requires a BCLK rate that is
	107	* minimum of 64x the LRCLK sample rate." DA7219 is the only clk
	108	* source so for all codecs we have to limit bclk to 64X lrclk.
	109	*/
	110	clk_set_rate(da7219_dai_wclk, 48000);
	111	clk_set_rate(da7219_dai_bclk, 48000 * 64);
bb24a31e	112	ret = clk_prepare_enable(da7219_dai_bclk);
c88d3115 AA	113	if (ret < 0) {
	114	dev_err(rtd->dev, "can't enable master clock %d\n", ret);
	115	return ret;
	116	}
	117
	118	return ret;
	119	}
	120
e9716ff3	121	static void da7219_clk_disable(void)
c88d3115	122	{
bb24a31e	123	clk_disable_unprepare(da7219_dai_bclk);
c88d3115 AA	124	}
c88d3115 AA	125
608a300f AA	126	static const unsigned int channels[] = {
	127	DUAL_CHANNEL,
	128	};
	129
	130	static const unsigned int rates[] = {
	131	48000,
	132	};
	133
	134	static const struct snd_pcm_hw_constraint_list constraints_rates = {
	135	.count = ARRAY_SIZE(rates),
	136	.list = rates,
	137	.mask = 0,
	138	};
	139
	140	static const struct snd_pcm_hw_constraint_list constraints_channels = {
	141	.count = ARRAY_SIZE(channels),
	142	.list = channels,
	143	.mask = 0,
	144	};
	145
8dcb0c90	146	static int cz_da7219_play_startup(struct snd_pcm_substream *substream)
608a300f AA	147	{
608a300f AA	148	struct snd_pcm_runtime *runtime = substream->runtime;
ccfbb4f5 MV	149	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	150	struct snd_soc_card *card = rtd->card;
	151	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
608a300f AA	152
	153	/*
	154	* On this platform for PCM device we support stereo
	155	*/
	156
	157	runtime->hw.channels_max = DUAL_CHANNEL;
	158	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	159	&constraints_channels);
	160	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
	161	&constraints_rates);
	162
8dcb0c90	163	machine->play_i2s_instance = I2S_SP_INSTANCE;
756ae8f2	164	return da7219_clk_enable(substream);
8dcb0c90 AA	165	}
	166
	167	static int cz_da7219_cap_startup(struct snd_pcm_substream *substream)
	168	{
	169	struct snd_pcm_runtime *runtime = substream->runtime;
	170	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	171	struct snd_soc_card *card = rtd->card;
	172	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
	173
	174	/*
	175	* On this platform for PCM device we support stereo
	176	*/
	177
	178	runtime->hw.channels_max = DUAL_CHANNEL;
	179	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	180	&constraints_channels);
	181	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
	182	&constraints_rates);
	183
	184	machine->cap_i2s_instance = I2S_SP_INSTANCE;
2718c89a	185	machine->capture_channel = CAP_CHANNEL1;
756ae8f2	186	return da7219_clk_enable(substream);
e9716ff3 AA	187	}
	188
	189	static int cz_max_startup(struct snd_pcm_substream *substream)
	190	{
c736cbd3	191	struct snd_pcm_runtime *runtime = substream->runtime;
ccfbb4f5 MV	192	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	193	struct snd_soc_card *card = rtd->card;
	194	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
	195
c736cbd3 AA	196	/*
	197	* On this platform for PCM device we support stereo
	198	*/
	199
	200	runtime->hw.channels_max = DUAL_CHANNEL;
	201	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	202	&constraints_channels);
	203	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
	204	&constraints_rates);
	205
8dcb0c90	206	machine->play_i2s_instance = I2S_BT_INSTANCE;
756ae8f2	207	return da7219_clk_enable(substream);
e9716ff3 AA	208	}
e9716ff3 AA	209
2718c89a	210	static int cz_dmic0_startup(struct snd_pcm_substream *substream)
e9716ff3	211	{
c736cbd3	212	struct snd_pcm_runtime *runtime = substream->runtime;
ccfbb4f5 MV	213	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	214	struct snd_soc_card *card = rtd->card;
	215	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
	216
c736cbd3 AA	217	/*
	218	* On this platform for PCM device we support stereo
	219	*/
	220
	221	runtime->hw.channels_max = DUAL_CHANNEL;
	222	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	223	&constraints_channels);
	224	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
	225	&constraints_rates);
	226
8dcb0c90	227	machine->cap_i2s_instance = I2S_BT_INSTANCE;
756ae8f2	228	return da7219_clk_enable(substream);
e9716ff3 AA	229	}
e9716ff3 AA	230
2718c89a AA	231	static int cz_dmic1_startup(struct snd_pcm_substream *substream)
2718c89a AA	232	{
c736cbd3	233	struct snd_pcm_runtime *runtime = substream->runtime;
2718c89a AA	234	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	235	struct snd_soc_card *card = rtd->card;
	236	struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
	237
c736cbd3 AA	238	/*
	239	* On this platform for PCM device we support stereo
	240	*/
	241
	242	runtime->hw.channels_max = DUAL_CHANNEL;
	243	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	244	&constraints_channels);
	245	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
	246	&constraints_rates);
	247
8dcb0c90	248	machine->cap_i2s_instance = I2S_SP_INSTANCE;
2718c89a	249	machine->capture_channel = CAP_CHANNEL0;
756ae8f2	250	return da7219_clk_enable(substream);
bb24a31e AA	251	}
	252
	253	static void cz_da7219_shutdown(struct snd_pcm_substream *substream)
e9716ff3 AA	254	{
e9716ff3 AA	255	da7219_clk_disable();
608a300f AA	256	}
608a300f AA	257
8dcb0c90 AA	258	static const struct snd_soc_ops cz_da7219_play_ops = {
	259	.startup = cz_da7219_play_startup,
	260	.shutdown = cz_da7219_shutdown,
	261	};
	262
839a12c7	263	static const struct snd_soc_ops cz_da7219_cap_ops = {
8dcb0c90	264	.startup = cz_da7219_cap_startup,
e9716ff3	265	.shutdown = cz_da7219_shutdown,
608a300f AA	266	};
608a300f AA	267
839a12c7	268	static const struct snd_soc_ops cz_max_play_ops = {
e9716ff3	269	.startup = cz_max_startup,
bb24a31e	270	.shutdown = cz_da7219_shutdown,
c88d3115 AA	271	};
c88d3115 AA	272
2718c89a AA	273	static const struct snd_soc_ops cz_dmic0_cap_ops = {
2718c89a AA	274	.startup = cz_dmic0_startup,
bb24a31e	275	.shutdown = cz_da7219_shutdown,
2718c89a AA	276	};
	277
	278	static const struct snd_soc_ops cz_dmic1_cap_ops = {
	279	.startup = cz_dmic1_startup,
bb24a31e	280	.shutdown = cz_da7219_shutdown,
c88d3115 AA	281	};
c88d3115 AA	282
48696d0a KM	283	SND_SOC_DAILINK_DEF(designware1,
	284	DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.1.auto")));
	285	SND_SOC_DAILINK_DEF(designware2,
	286	DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.2.auto")));
	287	SND_SOC_DAILINK_DEF(designware3,
	288	DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.3.auto")));
	289
	290	SND_SOC_DAILINK_DEF(dlgs,
	291	DAILINK_COMP_ARRAY(COMP_CODEC("i2c-DLGS7219:00", "da7219-hifi")));
	292	SND_SOC_DAILINK_DEF(mx,
	293	DAILINK_COMP_ARRAY(COMP_CODEC("MX98357A:00", "HiFi")));
	294	SND_SOC_DAILINK_DEF(adau,
	295	DAILINK_COMP_ARRAY(COMP_CODEC("ADAU7002:00", "adau7002-hifi")));
	296
	297	SND_SOC_DAILINK_DEF(platform,
	298	DAILINK_COMP_ARRAY(COMP_PLATFORM("acp_audio_dma.0.auto")));
	299
608a300f AA	300	static struct snd_soc_dai_link cz_dai_7219_98357[] = {
608a300f AA	301	{
3bec6fa3 AA	302	.name = "amd-da7219-play",
3bec6fa3 AA	303	.stream_name = "Playback",
608a300f AA	304	.dai_fmt = SND_SOC_DAIFMT_I2S \| SND_SOC_DAIFMT_NB_NF
	305	\| SND_SOC_DAIFMT_CBM_CFM,
	306	.init = cz_da7219_init,
	307	.dpcm_playback = 1,
8dcb0c90	308	.ops = &cz_da7219_play_ops,
48696d0a	309	SND_SOC_DAILINK_REG(designware1, dlgs, platform),
3bec6fa3 AA	310	},
	311	{
	312	.name = "amd-da7219-cap",
	313	.stream_name = "Capture",
3bec6fa3 AA	314	.dai_fmt = SND_SOC_DAIFMT_I2S \| SND_SOC_DAIFMT_NB_NF
3bec6fa3 AA	315	\| SND_SOC_DAIFMT_CBM_CFM,
608a300f AA	316	.dpcm_capture = 1,
608a300f AA	317	.ops = &cz_da7219_cap_ops,
48696d0a	318	SND_SOC_DAILINK_REG(designware2, dlgs, platform),
608a300f AA	319	},
	320	{
	321	.name = "amd-max98357-play",
	322	.stream_name = "HiFi Playback",
608a300f AA	323	.dai_fmt = SND_SOC_DAIFMT_I2S \| SND_SOC_DAIFMT_NB_NF
	324	\| SND_SOC_DAIFMT_CBM_CFM,
	325	.dpcm_playback = 1,
c88d3115	326	.ops = &cz_max_play_ops,
48696d0a	327	SND_SOC_DAILINK_REG(designware3, mx, platform),
608a300f AA	328	},
608a300f AA	329	{
2718c89a AA	330	/* C panel DMIC */
	331	.name = "dmic0",
	332	.stream_name = "DMIC0 Capture",
608a300f AA	333	.dai_fmt = SND_SOC_DAIFMT_I2S \| SND_SOC_DAIFMT_NB_NF
	334	\| SND_SOC_DAIFMT_CBM_CFM,
	335	.dpcm_capture = 1,
2718c89a	336	.ops = &cz_dmic0_cap_ops,
48696d0a	337	SND_SOC_DAILINK_REG(designware3, adau, platform),
2718c89a AA	338	},
	339	{
	340	/* A/B panel DMIC */
	341	.name = "dmic1",
	342	.stream_name = "DMIC1 Capture",
2718c89a AA	343	.dai_fmt = SND_SOC_DAIFMT_I2S \| SND_SOC_DAIFMT_NB_NF
	344	\| SND_SOC_DAIFMT_CBM_CFM,
	345	.dpcm_capture = 1,
	346	.ops = &cz_dmic1_cap_ops,
48696d0a	347	SND_SOC_DAILINK_REG(designware2, adau, platform),
608a300f AA	348	},
	349	};
	350
	351	static const struct snd_soc_dapm_widget cz_widgets[] = {
	352	SND_SOC_DAPM_HP("Headphones", NULL),
	353	SND_SOC_DAPM_SPK("Speakers", NULL),
	354	SND_SOC_DAPM_MIC("Headset Mic", NULL),
	355	SND_SOC_DAPM_MIC("Int Mic", NULL),
	356	};
	357
	358	static const struct snd_soc_dapm_route cz_audio_route[] = {
	359	{"Headphones", NULL, "HPL"},
	360	{"Headphones", NULL, "HPR"},
	361	{"MIC", NULL, "Headset Mic"},
	362	{"Speakers", NULL, "Speaker"},
	363	{"PDM_DAT", NULL, "Int Mic"},
	364	};
	365
	366	static const struct snd_kcontrol_new cz_mc_controls[] = {
	367	SOC_DAPM_PIN_SWITCH("Headphones"),
	368	SOC_DAPM_PIN_SWITCH("Speakers"),
	369	SOC_DAPM_PIN_SWITCH("Headset Mic"),
	370	SOC_DAPM_PIN_SWITCH("Int Mic"),
	371	};
	372
	373	static struct snd_soc_card cz_card = {
	374	.name = "acpd7219m98357",
	375	.owner = THIS_MODULE,
	376	.dai_link = cz_dai_7219_98357,
	377	.num_links = ARRAY_SIZE(cz_dai_7219_98357),
	378	.dapm_widgets = cz_widgets,
	379	.num_dapm_widgets = ARRAY_SIZE(cz_widgets),
	380	.dapm_routes = cz_audio_route,
	381	.num_dapm_routes = ARRAY_SIZE(cz_audio_route),
	382	.controls = cz_mc_controls,
	383	.num_controls = ARRAY_SIZE(cz_mc_controls),
	384	};
	385
c183fec1 AA	386	static struct regulator_consumer_supply acp_da7219_supplies[] = {
	387	REGULATOR_SUPPLY("VDD", "i2c-DLGS7219:00"),
	388	REGULATOR_SUPPLY("VDDMIC", "i2c-DLGS7219:00"),
	389	REGULATOR_SUPPLY("VDDIO", "i2c-DLGS7219:00"),
	390	REGULATOR_SUPPLY("IOVDD", "ADAU7002:00"),
	391	};
	392
	393	static struct regulator_init_data acp_da7219_data = {
	394	.constraints = {
	395	.always_on = 1,
	396	},
	397	.num_consumer_supplies = ARRAY_SIZE(acp_da7219_supplies),
	398	.consumer_supplies = acp_da7219_supplies,
	399	};
	400
	401	static struct regulator_config acp_da7219_cfg = {
	402	.init_data = &acp_da7219_data,
	403	};
	404
	405	static struct regulator_ops acp_da7219_ops = {
	406	};
	407
de363648	408	static const struct regulator_desc acp_da7219_desc = {
c183fec1 AA	409	.name = "reg-fixed-1.8V",
	410	.type = REGULATOR_VOLTAGE,
	411	.owner = THIS_MODULE,
	412	.ops = &acp_da7219_ops,
	413	.fixed_uV = 1800000, /* 1.8V */
	414	.n_voltages = 1,
	415	};
	416
608a300f AA	417	static int cz_probe(struct platform_device *pdev)
	418	{
	419	int ret;
	420	struct snd_soc_card *card;
ccfbb4f5	421	struct acp_platform_info *machine;
c183fec1 AA	422	struct regulator_dev *rdev;
	423
	424	acp_da7219_cfg.dev = &pdev->dev;
	425	rdev = devm_regulator_register(&pdev->dev, &acp_da7219_desc,
	426	&acp_da7219_cfg);
	427	if (IS_ERR(rdev)) {
	428	dev_err(&pdev->dev, "Failed to register regulator: %d\n",
76996760	429	(int)PTR_ERR(rdev));
c183fec1 AA	430	return -EINVAL;
c183fec1 AA	431	}
608a300f	432
ccfbb4f5 MV	433	machine = devm_kzalloc(&pdev->dev, sizeof(struct acp_platform_info),
	434	GFP_KERNEL);
	435	if (!machine)
	436	return -ENOMEM;
608a300f AA	437	card = &cz_card;
	438	cz_card.dev = &pdev->dev;
	439	platform_set_drvdata(pdev, card);
ccfbb4f5	440	snd_soc_card_set_drvdata(card, machine);
608a300f AA	441	ret = devm_snd_soc_register_card(&pdev->dev, &cz_card);
	442	if (ret) {
	443	dev_err(&pdev->dev,
	444	"devm_snd_soc_register_card(%s) failed: %d\n",
	445	cz_card.name, ret);
	446	return ret;
	447	}
ccfbb4f5 MV	448	bt_uart_enable = !device_property_read_bool(&pdev->dev,
ccfbb4f5 MV	449	"bt-pad-enable");
608a300f AA	450	return 0;
	451	}
	452
	453	static const struct acpi_device_id cz_audio_acpi_match[] = {
	454	{ "AMD7219", 0 },
	455	{},
	456	};
	457	MODULE_DEVICE_TABLE(acpi, cz_audio_acpi_match);
	458
	459	static struct platform_driver cz_pcm_driver = {
	460	.driver = {
	461	.name = "cz-da7219-max98357a",
	462	.acpi_match_table = ACPI_PTR(cz_audio_acpi_match),
	463	.pm = &snd_soc_pm_ops,
	464	},
	465	.probe = cz_probe,
	466	};
	467
	468	module_platform_driver(cz_pcm_driver);
	469
	470	MODULE_AUTHOR("akshu.agrawal@amd.com");
	471	MODULE_DESCRIPTION("DA7219 & MAX98357A audio support");
	472	MODULE_LICENSE("GPL v2");