[mirror_ubuntu-jammy-kernel.git] / sound / soc / img / pistachio-internal-dac.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Pistachio internal dac driver
 *
 * Copyright (C) 2015 Imagination Technologies Ltd.
 *
 * Author: Damien Horsley <Damien.Horsley@imgtec.com>
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>

#include <sound/pcm_params.h>
#include <sound/soc.h>

#define PISTACHIO_INTERNAL_DAC_CTRL			0x40
#define PISTACHIO_INTERNAL_DAC_CTRL_PWR_SEL_MASK	0x2
#define PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK		0x1

#define PISTACHIO_INTERNAL_DAC_SRST			0x44
#define PISTACHIO_INTERNAL_DAC_SRST_MASK		0x1

#define PISTACHIO_INTERNAL_DAC_GTI_CTRL			0x48
#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_SHIFT	0
#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_MASK	0xFFF
#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK		0x1000
#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_SHIFT	13
#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_MASK	0x1FE000

#define PISTACHIO_INTERNAL_DAC_PWR			0x1
#define PISTACHIO_INTERNAL_DAC_PWR_MASK			0x1

#define PISTACHIO_INTERNAL_DAC_FORMATS (SNDRV_PCM_FMTBIT_S24_LE |  \
					SNDRV_PCM_FMTBIT_S32_LE)

/* codec private data */
struct pistachio_internal_dac {
	struct regmap *regmap;
	struct regulator *supply;
	bool mute;
};

static const struct snd_kcontrol_new pistachio_internal_dac_snd_controls[] = {
	SOC_SINGLE("Playback Switch", PISTACHIO_INTERNAL_DAC_CTRL, 2, 1, 1)
};

static const struct snd_soc_dapm_widget pistachio_internal_dac_widgets[] = {
	SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM, 0, 0),
	SND_SOC_DAPM_OUTPUT("AOUTL"),
	SND_SOC_DAPM_OUTPUT("AOUTR"),
};

static const struct snd_soc_dapm_route pistachio_internal_dac_routes[] = {
	{ "AOUTL", NULL, "DAC" },
	{ "AOUTR", NULL, "DAC" },
};

static void pistachio_internal_dac_reg_writel(struct regmap *top_regs,
						u32 val, u32 reg)
{
	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
			PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_MASK,
			reg << PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_SHIFT);

	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
			PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_MASK,
			val << PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_SHIFT);

	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
			PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK,
			PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK);

	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
			PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK, 0);
}

static void pistachio_internal_dac_pwr_off(struct pistachio_internal_dac *dac)
{
	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_CTRL,
		PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK,
		PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK);

	pistachio_internal_dac_reg_writel(dac->regmap, 0,
					PISTACHIO_INTERNAL_DAC_PWR);
}

static void pistachio_internal_dac_pwr_on(struct pistachio_internal_dac *dac)
{
	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_SRST,
			PISTACHIO_INTERNAL_DAC_SRST_MASK,
			PISTACHIO_INTERNAL_DAC_SRST_MASK);

	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_SRST,
			PISTACHIO_INTERNAL_DAC_SRST_MASK, 0);

	pistachio_internal_dac_reg_writel(dac->regmap,
					PISTACHIO_INTERNAL_DAC_PWR_MASK,
					PISTACHIO_INTERNAL_DAC_PWR);

	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_CTRL,
			PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK, 0);
}

static struct snd_soc_dai_driver pistachio_internal_dac_dais[] = {
	{
		.name = "pistachio_internal_dac",
		.playback = {
			.stream_name = "Playback",
			.channels_min = 2,
			.channels_max = 2,
			.rates = SNDRV_PCM_RATE_8000_48000,
			.formats = PISTACHIO_INTERNAL_DAC_FORMATS,
		}
	},
};

static int pistachio_internal_dac_codec_probe(struct snd_soc_component *component)
{
	struct pistachio_internal_dac *dac = snd_soc_component_get_drvdata(component);

	snd_soc_component_init_regmap(component, dac->regmap);

	return 0;
}

static const struct snd_soc_component_driver pistachio_internal_dac_driver = {
	.probe			= pistachio_internal_dac_codec_probe,
	.controls		= pistachio_internal_dac_snd_controls,
	.num_controls		= ARRAY_SIZE(pistachio_internal_dac_snd_controls),
	.dapm_widgets		= pistachio_internal_dac_widgets,
	.num_dapm_widgets	= ARRAY_SIZE(pistachio_internal_dac_widgets),
	.dapm_routes		= pistachio_internal_dac_routes,
	.num_dapm_routes	= ARRAY_SIZE(pistachio_internal_dac_routes),
	.use_pmdown_time	= 1,
	.endianness		= 1,
	.non_legacy_dai_naming	= 1,
};

static int pistachio_internal_dac_probe(struct platform_device *pdev)
{
	struct pistachio_internal_dac *dac;
	int ret, voltage;
	struct device *dev = &pdev->dev;
	u32 reg;

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

	if (!dac)
		return -ENOMEM;

	platform_set_drvdata(pdev, dac);

	dac->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
							    "img,cr-top");
	if (IS_ERR(dac->regmap))
		return PTR_ERR(dac->regmap);

	dac->supply = devm_regulator_get(dev, "VDD");
	if (IS_ERR(dac->supply)) {
		ret = PTR_ERR(dac->supply);
		if (ret != -EPROBE_DEFER)
			dev_err(dev, "failed to acquire supply 'VDD-supply': %d\n", ret);
		return ret;
	}

	ret = regulator_enable(dac->supply);
	if (ret) {
		dev_err(dev, "failed to enable supply: %d\n", ret);
		return ret;
	}

	voltage = regulator_get_voltage(dac->supply);

	switch (voltage) {
	case 1800000:
		reg = 0;
		break;
	case 3300000:
		reg = PISTACHIO_INTERNAL_DAC_CTRL_PWR_SEL_MASK;
		break;
	default:
		dev_err(dev, "invalid voltage: %d\n", voltage);
		ret = -EINVAL;
		goto err_regulator;
	}

	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_CTRL,
			PISTACHIO_INTERNAL_DAC_CTRL_PWR_SEL_MASK, reg);

	pistachio_internal_dac_pwr_off(dac);
	pistachio_internal_dac_pwr_on(dac);

	pm_runtime_set_active(dev);
	pm_runtime_enable(dev);
	pm_runtime_idle(dev);

	ret = devm_snd_soc_register_component(dev,
			&pistachio_internal_dac_driver,
			pistachio_internal_dac_dais,
			ARRAY_SIZE(pistachio_internal_dac_dais));
	if (ret) {
		dev_err(dev, "failed to register component: %d\n", ret);
		goto err_pwr;
	}

	return 0;

err_pwr:
	pm_runtime_disable(&pdev->dev);
	pistachio_internal_dac_pwr_off(dac);
err_regulator:
	regulator_disable(dac->supply);

	return ret;
}

static int pistachio_internal_dac_remove(struct platform_device *pdev)
{
	struct pistachio_internal_dac *dac = dev_get_drvdata(&pdev->dev);

	pm_runtime_disable(&pdev->dev);
	pistachio_internal_dac_pwr_off(dac);
	regulator_disable(dac->supply);

	return 0;
}

#ifdef CONFIG_PM
static int pistachio_internal_dac_rt_resume(struct device *dev)
{
	struct pistachio_internal_dac *dac = dev_get_drvdata(dev);
	int ret;

	ret = regulator_enable(dac->supply);
	if (ret) {
		dev_err(dev, "failed to enable supply: %d\n", ret);
		return ret;
	}

	pistachio_internal_dac_pwr_on(dac);

	return 0;
}

static int pistachio_internal_dac_rt_suspend(struct device *dev)
{
	struct pistachio_internal_dac *dac = dev_get_drvdata(dev);

	pistachio_internal_dac_pwr_off(dac);

	regulator_disable(dac->supply);

	return 0;
}
#endif

static const struct dev_pm_ops pistachio_internal_dac_pm_ops = {
	SET_RUNTIME_PM_OPS(pistachio_internal_dac_rt_suspend,
			pistachio_internal_dac_rt_resume, NULL)
};

static const struct of_device_id pistachio_internal_dac_of_match[] = {
	{ .compatible = "img,pistachio-internal-dac" },
	{}
};
MODULE_DEVICE_TABLE(of, pistachio_internal_dac_of_match);

static struct platform_driver pistachio_internal_dac_plat_driver = {
	.driver = {
		.name = "img-pistachio-internal-dac",
		.of_match_table = pistachio_internal_dac_of_match,
		.pm = &pistachio_internal_dac_pm_ops
	},
	.probe = pistachio_internal_dac_probe,
	.remove = pistachio_internal_dac_remove
};
module_platform_driver(pistachio_internal_dac_plat_driver);

MODULE_DESCRIPTION("Pistachio Internal DAC driver");
MODULE_AUTHOR("Damien Horsley <Damien.Horsley@imgtec.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
75a6faf6	1	// SPDX-License-Identifier: GPL-2.0-only
39503622 DH	2	/*
	3	* Pistachio internal dac driver
	4	*
	5	* Copyright (C) 2015 Imagination Technologies Ltd.
	6	*
	7	* Author: Damien Horsley <Damien.Horsley@imgtec.com>
39503622 DH	8	*/
	9
	10	#include <linux/clk.h>
	11	#include <linux/delay.h>
	12	#include <linux/mfd/syscon.h>
	13	#include <linux/module.h>
	14	#include <linux/pm_runtime.h>
	15	#include <linux/regmap.h>
	16	#include <linux/regulator/consumer.h>
	17
	18	#include <sound/pcm_params.h>
	19	#include <sound/soc.h>
	20
	21	#define PISTACHIO_INTERNAL_DAC_CTRL 0x40
	22	#define PISTACHIO_INTERNAL_DAC_CTRL_PWR_SEL_MASK 0x2
	23	#define PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK 0x1
	24
	25	#define PISTACHIO_INTERNAL_DAC_SRST 0x44
	26	#define PISTACHIO_INTERNAL_DAC_SRST_MASK 0x1
	27
	28	#define PISTACHIO_INTERNAL_DAC_GTI_CTRL 0x48
	29	#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_SHIFT 0
	30	#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_MASK 0xFFF
	31	#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK 0x1000
	32	#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_SHIFT 13
	33	#define PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_MASK 0x1FE000
	34
	35	#define PISTACHIO_INTERNAL_DAC_PWR 0x1
	36	#define PISTACHIO_INTERNAL_DAC_PWR_MASK 0x1
	37
	38	#define PISTACHIO_INTERNAL_DAC_FORMATS (SNDRV_PCM_FMTBIT_S24_LE \| \
	39	SNDRV_PCM_FMTBIT_S32_LE)
	40
	41	/* codec private data */
	42	struct pistachio_internal_dac {
	43	struct regmap *regmap;
	44	struct regulator *supply;
	45	bool mute;
	46	};
	47
	48	static const struct snd_kcontrol_new pistachio_internal_dac_snd_controls[] = {
	49	SOC_SINGLE("Playback Switch", PISTACHIO_INTERNAL_DAC_CTRL, 2, 1, 1)
	50	};
	51
	52	static const struct snd_soc_dapm_widget pistachio_internal_dac_widgets[] = {
	53	SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM, 0, 0),
	54	SND_SOC_DAPM_OUTPUT("AOUTL"),
	55	SND_SOC_DAPM_OUTPUT("AOUTR"),
	56	};
	57
	58	static const struct snd_soc_dapm_route pistachio_internal_dac_routes[] = {
	59	{ "AOUTL", NULL, "DAC" },
	60	{ "AOUTR", NULL, "DAC" },
	61	};
	62
	63	static void pistachio_internal_dac_reg_writel(struct regmap *top_regs,
	64	u32 val, u32 reg)
	65	{
	66	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
	67	PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_MASK,
	68	reg << PISTACHIO_INTERNAL_DAC_GTI_CTRL_ADDR_SHIFT);
	69
	70	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
	71	PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_MASK,
72	val << PISTACHIO_INTERNAL_DAC_GTI_CTRL_WDATA_SHIFT);
73
74	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
75	PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK,
76	PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK);
77
78	regmap_update_bits(top_regs, PISTACHIO_INTERNAL_DAC_GTI_CTRL,
79	PISTACHIO_INTERNAL_DAC_GTI_CTRL_WE_MASK, 0);
80	}
81
82	static void pistachio_internal_dac_pwr_off(struct pistachio_internal_dac *dac)
83	{
84	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_CTRL,
85	PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK,
86	PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK);
87
88	pistachio_internal_dac_reg_writel(dac->regmap, 0,
89	PISTACHIO_INTERNAL_DAC_PWR);
90	}
91
92	static void pistachio_internal_dac_pwr_on(struct pistachio_internal_dac *dac)
93	{
94	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_SRST,
95	PISTACHIO_INTERNAL_DAC_SRST_MASK,
96	PISTACHIO_INTERNAL_DAC_SRST_MASK);
97
98	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_SRST,
99	PISTACHIO_INTERNAL_DAC_SRST_MASK, 0);
100
101	pistachio_internal_dac_reg_writel(dac->regmap,
102	PISTACHIO_INTERNAL_DAC_PWR_MASK,
103	PISTACHIO_INTERNAL_DAC_PWR);
104
105	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_CTRL,
106	PISTACHIO_INTERNAL_DAC_CTRL_PWRDN_MASK, 0);
107	}
108
109	static struct snd_soc_dai_driver pistachio_internal_dac_dais[] = {
110	{
111	.name = "pistachio_internal_dac",
112	.playback = {
113	.stream_name = "Playback",
114	.channels_min = 2,
115	.channels_max = 2,
116	.rates = SNDRV_PCM_RATE_8000_48000,
117	.formats = PISTACHIO_INTERNAL_DAC_FORMATS,
118	}
119	},
120	};
121
8dc906d3	122	static int pistachio_internal_dac_codec_probe(struct snd_soc_component *component)
39503622	123	{
8dc906d3	124	struct pistachio_internal_dac *dac = snd_soc_component_get_drvdata(component);
39503622	125
8dc906d3	126	snd_soc_component_init_regmap(component, dac->regmap);
39503622 DH	127
	128	return 0;
	129	}
	130
8dc906d3 KM	131	static const struct snd_soc_component_driver pistachio_internal_dac_driver = {
	132	.probe = pistachio_internal_dac_codec_probe,
	133	.controls = pistachio_internal_dac_snd_controls,
	134	.num_controls = ARRAY_SIZE(pistachio_internal_dac_snd_controls),
	135	.dapm_widgets = pistachio_internal_dac_widgets,
	136	.num_dapm_widgets = ARRAY_SIZE(pistachio_internal_dac_widgets),
	137	.dapm_routes = pistachio_internal_dac_routes,
	138	.num_dapm_routes = ARRAY_SIZE(pistachio_internal_dac_routes),
	139	.use_pmdown_time = 1,
	140	.endianness = 1,
	141	.non_legacy_dai_naming = 1,
39503622 DH	142	};
	143
	144	static int pistachio_internal_dac_probe(struct platform_device *pdev)
	145	{
	146	struct pistachio_internal_dac *dac;
	147	int ret, voltage;
	148	struct device *dev = &pdev->dev;
	149	u32 reg;
	150
	151	dac = devm_kzalloc(dev, sizeof(*dac), GFP_KERNEL);
	152
	153	if (!dac)
	154	return -ENOMEM;
	155
	156	platform_set_drvdata(pdev, dac);
	157
	158	dac->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
	159	"img,cr-top");
	160	if (IS_ERR(dac->regmap))
	161	return PTR_ERR(dac->regmap);
	162
	163	dac->supply = devm_regulator_get(dev, "VDD");
	164	if (IS_ERR(dac->supply)) {
	165	ret = PTR_ERR(dac->supply);
	166	if (ret != -EPROBE_DEFER)
	167	dev_err(dev, "failed to acquire supply 'VDD-supply': %d\n", ret);
	168	return ret;
	169	}
	170
	171	ret = regulator_enable(dac->supply);
	172	if (ret) {
	173	dev_err(dev, "failed to enable supply: %d\n", ret);
	174	return ret;
	175	}
	176
	177	voltage = regulator_get_voltage(dac->supply);
	178
	179	switch (voltage) {
	180	case 1800000:
	181	reg = 0;
	182	break;
	183	case 3300000:
	184	reg = PISTACHIO_INTERNAL_DAC_CTRL_PWR_SEL_MASK;
	185	break;
	186	default:
	187	dev_err(dev, "invalid voltage: %d\n", voltage);
	188	ret = -EINVAL;
	189	goto err_regulator;
	190	}
	191
	192	regmap_update_bits(dac->regmap, PISTACHIO_INTERNAL_DAC_CTRL,
	193	PISTACHIO_INTERNAL_DAC_CTRL_PWR_SEL_MASK, reg);
	194
	195	pistachio_internal_dac_pwr_off(dac);
	196	pistachio_internal_dac_pwr_on(dac);
	197
	198	pm_runtime_set_active(dev);
	199	pm_runtime_enable(dev);
	200	pm_runtime_idle(dev);
	201
8dc906d3 KM	202	ret = devm_snd_soc_register_component(dev,
8dc906d3 KM	203	&pistachio_internal_dac_driver,
39503622 DH	204	pistachio_internal_dac_dais,
	205	ARRAY_SIZE(pistachio_internal_dac_dais));
	206	if (ret) {
8dc906d3	207	dev_err(dev, "failed to register component: %d\n", ret);
39503622 DH	208	goto err_pwr;
	209	}
	210
	211	return 0;
	212
	213	err_pwr:
	214	pm_runtime_disable(&pdev->dev);
	215	pistachio_internal_dac_pwr_off(dac);
	216	err_regulator:
	217	regulator_disable(dac->supply);
	218
	219	return ret;
	220	}
	221
	222	static int pistachio_internal_dac_remove(struct platform_device *pdev)
	223	{
	224	struct pistachio_internal_dac *dac = dev_get_drvdata(&pdev->dev);
	225
39503622 DH	226	pm_runtime_disable(&pdev->dev);
	227	pistachio_internal_dac_pwr_off(dac);
	228	regulator_disable(dac->supply);
	229
	230	return 0;
	231	}
	232
	233	#ifdef CONFIG_PM
	234	static int pistachio_internal_dac_rt_resume(struct device *dev)
	235	{
	236	struct pistachio_internal_dac *dac = dev_get_drvdata(dev);
	237	int ret;
	238
	239	ret = regulator_enable(dac->supply);
	240	if (ret) {
	241	dev_err(dev, "failed to enable supply: %d\n", ret);
	242	return ret;
	243	}
	244
	245	pistachio_internal_dac_pwr_on(dac);
	246
	247	return 0;
	248	}
	249
	250	static int pistachio_internal_dac_rt_suspend(struct device *dev)
	251	{
	252	struct pistachio_internal_dac *dac = dev_get_drvdata(dev);
	253
	254	pistachio_internal_dac_pwr_off(dac);
	255
	256	regulator_disable(dac->supply);
	257
	258	return 0;
	259	}
	260	#endif
	261
	262	static const struct dev_pm_ops pistachio_internal_dac_pm_ops = {
	263	SET_RUNTIME_PM_OPS(pistachio_internal_dac_rt_suspend,
	264	pistachio_internal_dac_rt_resume, NULL)
	265	};
	266
	267	static const struct of_device_id pistachio_internal_dac_of_match[] = {
	268	{ .compatible = "img,pistachio-internal-dac" },
	269	{}
	270	};
	271	MODULE_DEVICE_TABLE(of, pistachio_internal_dac_of_match);
	272
	273	static struct platform_driver pistachio_internal_dac_plat_driver = {
	274	.driver = {
	275	.name = "img-pistachio-internal-dac",
	276	.of_match_table = pistachio_internal_dac_of_match,
	277	.pm = &pistachio_internal_dac_pm_ops
	278	},
	279	.probe = pistachio_internal_dac_probe,
	280	.remove = pistachio_internal_dac_remove
	281	};
	282	module_platform_driver(pistachio_internal_dac_plat_driver);
	283
	284	MODULE_DESCRIPTION("Pistachio Internal DAC driver");
	285	MODULE_AUTHOR("Damien Horsley <Damien.Horsley@imgtec.com>");
	286	MODULE_LICENSE("GPL v2");