mt6660.c

  1// SPDX-License-Identifier: GPL-2.0
  2
  3// Copyright (c) 2019 MediaTek Inc.
  4
  5#include <linux/module.h>
  6#include <linux/kernel.h>
  7#include <linux/err.h>
  8#include <linux/i2c.h>
  9#include <linux/pm_runtime.h>
 10#include <linux/delay.h>
 11#include <sound/soc.h>
 12#include <sound/tlv.h>
 13#include <sound/pcm_params.h>
 14
 15#include "mt6660.h"
 16
 17struct reg_size_table {
 18	u32 addr;
 19	u8 size;
 20};
 21
 22static const struct reg_size_table mt6660_reg_size_table[] = {
 23	{ MT6660_REG_HPF1_COEF, 4 },
 24	{ MT6660_REG_HPF2_COEF, 4 },
 25	{ MT6660_REG_TDM_CFG3, 2 },
 26	{ MT6660_REG_RESV17, 2 },
 27	{ MT6660_REG_RESV23, 2 },
 28	{ MT6660_REG_SIGMAX, 2 },
 29	{ MT6660_REG_DEVID, 2 },
 30	{ MT6660_REG_HCLIP_CTRL, 2 },
 31	{ MT6660_REG_DA_GAIN, 2 },
 32};
 33
 34static int mt6660_get_reg_size(uint32_t addr)
 35{
 36	int i;
 37
 38	for (i = 0; i < ARRAY_SIZE(mt6660_reg_size_table); i++) {
 39		if (mt6660_reg_size_table[i].addr == addr)
 40			return mt6660_reg_size_table[i].size;
 41	}
 42	return 1;
 43}
 44
 45static int mt6660_reg_write(void *context, unsigned int reg, unsigned int val)
 46{
 47	struct mt6660_chip *chip = context;
 48	int size = mt6660_get_reg_size(reg);
 49	u8 reg_data[4];
 50	int i;
 51
 52	for (i = 0; i < size; i++)
 53		reg_data[size - i - 1] = (val >> (8 * i)) & 0xff;
 54
 55	return i2c_smbus_write_i2c_block_data(chip->i2c, reg, size, reg_data);
 56}
 57
 58static int mt6660_reg_read(void *context, unsigned int reg, unsigned int *val)
 59{
 60	struct mt6660_chip *chip = context;
 61	int size = mt6660_get_reg_size(reg);
 62	int i, ret;
 63	u8 data[4];
 64	u32 reg_data = 0;
 65
 66	ret = i2c_smbus_read_i2c_block_data(chip->i2c, reg, size, data);
 67	if (ret < 0)
 68		return ret;
 69	for (i = 0; i < size; i++) {
 70		reg_data <<= 8;
 71		reg_data |= data[i];
 72	}
 73	*val = reg_data;
 74	return 0;
 75}
 76
 77static const struct regmap_config mt6660_regmap_config = {
 78	.reg_bits = 8,
 79	.val_bits = 32,
 80	.reg_write = mt6660_reg_write,
 81	.reg_read = mt6660_reg_read,
 82};
 83
 84static int mt6660_codec_dac_event(struct snd_soc_dapm_widget *w,
 85	struct snd_kcontrol *kcontrol, int event)
 86{
 87	if (event == SND_SOC_DAPM_POST_PMU)
 88		usleep_range(1000, 1100);
 89	return 0;
 90}
 91
 92static int mt6660_codec_classd_event(struct snd_soc_dapm_widget *w,
 93	struct snd_kcontrol *kcontrol, int event)
 94{
 95	struct snd_soc_component *component =
 96		snd_soc_dapm_to_component(w->dapm);
 97	int ret;
 98
 99	switch (event) {
100	case SND_SOC_DAPM_PRE_PMU:
101		dev_dbg(component->dev,
102			"%s: before classd turn on\n", __func__);
103		/* config to adaptive mode */
104		ret = snd_soc_component_update_bits(component,
105			MT6660_REG_BST_CTRL, 0x03, 0x03);
106		if (ret < 0) {
107			dev_err(component->dev, "config mode adaptive fail\n");
108			return ret;
109		}
110		break;
111	case SND_SOC_DAPM_POST_PMU:
112		/* voltage sensing enable */
113		ret = snd_soc_component_update_bits(component,
114			MT6660_REG_RESV7, 0x04, 0x04);
115		if (ret < 0) {
116			dev_err(component->dev,
117				"enable voltage sensing fail\n");
118			return ret;
119		}
120		dev_dbg(component->dev, "Amp on\n");
121		break;
122	case SND_SOC_DAPM_PRE_PMD:
123		dev_dbg(component->dev, "Amp off\n");
124		/* voltage sensing disable */
125		ret = snd_soc_component_update_bits(component,
126			MT6660_REG_RESV7, 0x04, 0x00);
127		if (ret < 0) {
128			dev_err(component->dev,
129				"disable voltage sensing fail\n");
130			return ret;
131		}
132		/* pop-noise improvement 1 */
133		ret = snd_soc_component_update_bits(component,
134			MT6660_REG_RESV10, 0x10, 0x10);
135		if (ret < 0) {
136			dev_err(component->dev,
137				"pop-noise improvement 1 fail\n");
138			return ret;
139		}
140		break;
141	case SND_SOC_DAPM_POST_PMD:
142		dev_dbg(component->dev,
143			"%s: after classd turn off\n", __func__);
144		/* pop-noise improvement 2 */
145		ret = snd_soc_component_update_bits(component,
146			MT6660_REG_RESV10, 0x10, 0x00);
147		if (ret < 0) {
148			dev_err(component->dev,
149				"pop-noise improvement 2 fail\n");
150			return ret;
151		}
152		/* config to off mode */
153		ret = snd_soc_component_update_bits(component,
154			MT6660_REG_BST_CTRL, 0x03, 0x00);
155		if (ret < 0) {
156			dev_err(component->dev, "config mode off fail\n");
157			return ret;
158		}
159		break;
160	}
161	return 0;
162}
163
164static const struct snd_soc_dapm_widget mt6660_component_dapm_widgets[] = {
165	SND_SOC_DAPM_DAC_E("DAC", NULL, MT6660_REG_PLL_CFG1,
166		0, 1, mt6660_codec_dac_event, SND_SOC_DAPM_POST_PMU),
167	SND_SOC_DAPM_ADC("VI ADC", NULL, SND_SOC_NOPM, 0, 0),
168	SND_SOC_DAPM_PGA("PGA", SND_SOC_NOPM, 0, 0, NULL, 0),
169	SND_SOC_DAPM_OUT_DRV_E("ClassD", MT6660_REG_SYSTEM_CTRL, 2, 0,
170			       NULL, 0, mt6660_codec_classd_event,
171			       SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
172			       SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
173	SND_SOC_DAPM_OUTPUT("OUTP"),
174	SND_SOC_DAPM_OUTPUT("OUTN"),
175};
176
177static const struct snd_soc_dapm_route mt6660_component_dapm_routes[] = {
178	{ "DAC", NULL, "aif_playback" },
179	{ "PGA", NULL, "DAC" },
180	{ "ClassD", NULL, "PGA" },
181	{ "OUTP", NULL, "ClassD" },
182	{ "OUTN", NULL, "ClassD" },
183	{ "VI ADC", NULL, "ClassD" },
184	{ "aif_capture", NULL, "VI ADC" },
185};
186
187static int mt6660_component_get_volsw(struct snd_kcontrol *kcontrol,
188				  struct snd_ctl_elem_value *ucontrol)
189{
190	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
191	struct mt6660_chip *chip = (struct mt6660_chip *)
192		snd_soc_component_get_drvdata(component);
193
194	ucontrol->value.integer.value[0] = chip->chip_rev & 0x0f;
195	return 0;
196}
197
198static const DECLARE_TLV_DB_SCALE(vol_ctl_tlv, -1155, 5, 0);
199
200static const struct snd_kcontrol_new mt6660_component_snd_controls[] = {
201	SOC_SINGLE_TLV("Digital Volume", MT6660_REG_VOL_CTRL, 0, 255,
202			   1, vol_ctl_tlv),
203	SOC_SINGLE("Hard Clip Switch", MT6660_REG_HCLIP_CTRL, 8, 1, 0),
204	SOC_SINGLE("Clip Switch", MT6660_REG_SPS_CTRL, 0, 1, 0),
205	SOC_SINGLE("Boost Mode", MT6660_REG_BST_CTRL, 0, 3, 0),
206	SOC_SINGLE("DRE Switch", MT6660_REG_DRE_CTRL, 0, 1, 0),
207	SOC_SINGLE("DC Protect Switch",	MT6660_REG_DC_PROTECT_CTRL, 3, 1, 0),
208	SOC_SINGLE("Data Output Left Channel Selection",
209		   MT6660_REG_DATAO_SEL, 3, 7, 0),
210	SOC_SINGLE("Data Output Right Channel Selection",
211		   MT6660_REG_DATAO_SEL, 0, 7, 0),
212	SOC_SINGLE_EXT("T0 SEL", MT6660_REG_CALI_T0, 0, 7, 0,
213		       snd_soc_get_volsw, NULL),
214	SOC_SINGLE_EXT("Chip Rev", MT6660_REG_DEVID, 8, 15, 0,
215		       mt6660_component_get_volsw, NULL),
216};
217
218static int _mt6660_chip_power_on(struct mt6660_chip *chip, int on_off)
219{
220	return regmap_write_bits(chip->regmap, MT6660_REG_SYSTEM_CTRL,
221				 0x01, on_off ? 0x00 : 0x01);
222}
223
224struct reg_table {
225	uint32_t addr;
226	uint32_t mask;
227	uint32_t val;
228};
229
230static const struct reg_table mt6660_setting_table[] = {
231	{ 0x20, 0x80, 0x00 },
232	{ 0x30, 0x01, 0x00 },
233	{ 0x50, 0x1c, 0x04 },
234	{ 0xB1, 0x0c, 0x00 },
235	{ 0xD3, 0x03, 0x03 },
236	{ 0xE0, 0x01, 0x00 },
237	{ 0x98, 0x44, 0x04 },
238	{ 0xB9, 0xff, 0x82 },
239	{ 0xB7, 0x7777, 0x7273 },
240	{ 0xB6, 0x07, 0x03 },
241	{ 0x6B, 0xe0, 0x20 },
242	{ 0x07, 0xff, 0x70 },
243	{ 0xBB, 0xff, 0x20 },
244	{ 0x69, 0xff, 0x40 },
245	{ 0xBD, 0xffff, 0x17f8 },
246	{ 0x70, 0xff, 0x15 },
247	{ 0x7C, 0xff, 0x00 },
248	{ 0x46, 0xff, 0x1d },
249	{ 0x1A, 0xffffffff, 0x7fdb7ffe },
250	{ 0x1B, 0xffffffff, 0x7fdb7ffe },
251	{ 0x51, 0xff, 0x58 },
252	{ 0xA2, 0xff, 0xce },
253	{ 0x33, 0xffff, 0x7fff },
254	{ 0x4C, 0xffff, 0x0116 },
255	{ 0x16, 0x1800, 0x0800 },
256	{ 0x68, 0x1f, 0x07 },
257};
258
259static int mt6660_component_setting(struct snd_soc_component *component)
260{
261	struct mt6660_chip *chip = snd_soc_component_get_drvdata(component);
262	int ret = 0;
263	size_t i = 0;
264
265	ret = _mt6660_chip_power_on(chip, 1);
266	if (ret < 0) {
267		dev_err(component->dev, "%s chip power on failed\n", __func__);
268		return ret;
269	}
270
271	for (i = 0; i < ARRAY_SIZE(mt6660_setting_table); i++) {
272		ret = snd_soc_component_update_bits(component,
273				mt6660_setting_table[i].addr,
274				mt6660_setting_table[i].mask,
275				mt6660_setting_table[i].val);
276		if (ret < 0) {
277			dev_err(component->dev, "%s update 0x%02x failed\n",
278				__func__, mt6660_setting_table[i].addr);
279			return ret;
280		}
281	}
282
283	ret = _mt6660_chip_power_on(chip, 0);
284	if (ret < 0) {
285		dev_err(component->dev, "%s chip power off failed\n", __func__);
286		return ret;
287	}
288
289	return 0;
290}
291
292static int mt6660_component_probe(struct snd_soc_component *component)
293{
294	struct mt6660_chip *chip = snd_soc_component_get_drvdata(component);
295	int ret;
296
297	dev_dbg(component->dev, "%s\n", __func__);
298	snd_soc_component_init_regmap(component, chip->regmap);
299
300	ret = mt6660_component_setting(component);
301	if (ret < 0)
302		dev_err(chip->dev, "mt6660 component setting failed\n");
303
304	return ret;
305}
306
307static void mt6660_component_remove(struct snd_soc_component *component)
308{
309	dev_dbg(component->dev, "%s\n", __func__);
310	snd_soc_component_exit_regmap(component);
311}
312
313static const struct snd_soc_component_driver mt6660_component_driver = {
314	.probe = mt6660_component_probe,
315	.remove = mt6660_component_remove,
316
317	.controls = mt6660_component_snd_controls,
318	.num_controls = ARRAY_SIZE(mt6660_component_snd_controls),
319	.dapm_widgets = mt6660_component_dapm_widgets,
320	.num_dapm_widgets = ARRAY_SIZE(mt6660_component_dapm_widgets),
321	.dapm_routes = mt6660_component_dapm_routes,
322	.num_dapm_routes = ARRAY_SIZE(mt6660_component_dapm_routes),
323
324	.idle_bias_on = false, /* idle_bias_off = true */
325	.endianness = 1,
326};
327
328static int mt6660_component_aif_hw_params(struct snd_pcm_substream *substream,
329	struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai)
330{
331	int word_len = params_physical_width(hw_params);
332	int aud_bit = params_width(hw_params);
333	u16 reg_data = 0;
334	int ret;
335
336	dev_dbg(dai->dev, "%s: ++\n", __func__);
337	dev_dbg(dai->dev, "format: 0x%08x\n", params_format(hw_params));
338	dev_dbg(dai->dev, "rate: 0x%08x\n", params_rate(hw_params));
339	dev_dbg(dai->dev, "word_len: %d, aud_bit: %d\n", word_len, aud_bit);
340	if (word_len > 32 || word_len < 16) {
341		dev_err(dai->dev, "not supported word length\n");
342		return -ENOTSUPP;
343	}
344	switch (aud_bit) {
345	case 16:
346		reg_data = 3;
347		break;
348	case 18:
349		reg_data = 2;
350		break;
351	case 20:
352		reg_data = 1;
353		break;
354	case 24:
355	case 32:
356		reg_data = 0;
357		break;
358	default:
359		return -ENOTSUPP;
360	}
361	ret = snd_soc_component_update_bits(dai->component,
362		MT6660_REG_SERIAL_CFG1, 0xc0, (reg_data << 6));
363	if (ret < 0) {
364		dev_err(dai->dev, "config aud bit fail\n");
365		return ret;
366	}
367	ret = snd_soc_component_update_bits(dai->component,
368		MT6660_REG_TDM_CFG3, 0x3f0, word_len << 4);
369	if (ret < 0) {
370		dev_err(dai->dev, "config word len fail\n");
371		return ret;
372	}
373	dev_dbg(dai->dev, "%s: --\n", __func__);
374	return 0;
375}
376
377static const struct snd_soc_dai_ops mt6660_component_aif_ops = {
378	.hw_params = mt6660_component_aif_hw_params,
379};
380
381#define STUB_RATES	SNDRV_PCM_RATE_8000_192000
382#define STUB_FORMATS	(SNDRV_PCM_FMTBIT_S16_LE | \
383			SNDRV_PCM_FMTBIT_U16_LE | \
384			SNDRV_PCM_FMTBIT_S24_LE | \
385			SNDRV_PCM_FMTBIT_U24_LE | \
386			SNDRV_PCM_FMTBIT_S32_LE | \
387			SNDRV_PCM_FMTBIT_U32_LE)
388
389static struct snd_soc_dai_driver mt6660_codec_dai = {
390	.name = "mt6660-aif",
391	.playback = {
392		.stream_name	= "aif_playback",
393		.channels_min	= 1,
394		.channels_max	= 2,
395		.rates		= STUB_RATES,
396		.formats	= STUB_FORMATS,
397	},
398	.capture = {
399		.stream_name	= "aif_capture",
400		.channels_min	= 1,
401		.channels_max	= 2,
402		.rates = STUB_RATES,
403		.formats = STUB_FORMATS,
404	},
405	/* dai properties */
406	.symmetric_rate = 1,
407	.symmetric_channels = 1,
408	.symmetric_sample_bits = 1,
409	/* dai operations */
410	.ops = &mt6660_component_aif_ops,
411};
412
413static int _mt6660_chip_id_check(struct mt6660_chip *chip)
414{
415	int ret;
416	unsigned int val;
417
418	ret = regmap_read(chip->regmap, MT6660_REG_DEVID, &val);
419	if (ret < 0)
420		return ret;
421	val &= 0x0ff0;
422	if (val != 0x00e0 && val != 0x01e0) {
423		dev_err(chip->dev, "%s id(%x) not match\n", __func__, val);
424		return -ENODEV;
425	}
426	return 0;
427}
428
429static int _mt6660_chip_sw_reset(struct mt6660_chip *chip)
430{
431	int ret;
432
433	/* turn on main pll first, then trigger reset */
434	ret = regmap_write(chip->regmap, MT6660_REG_SYSTEM_CTRL, 0x00);
435	if (ret < 0)
436		return ret;
437	ret = regmap_write(chip->regmap, MT6660_REG_SYSTEM_CTRL, 0x80);
438	if (ret < 0)
439		return ret;
440	msleep(30);
441	return 0;
442}
443
444static int _mt6660_read_chip_revision(struct mt6660_chip *chip)
445{
446	int ret;
447	unsigned int val;
448
449	ret = regmap_read(chip->regmap, MT6660_REG_DEVID, &val);
450	if (ret < 0) {
451		dev_err(chip->dev, "get chip revision fail\n");
452		return ret;
453	}
454	chip->chip_rev = val&0xff;
455	dev_info(chip->dev, "%s chip_rev = %x\n", __func__, chip->chip_rev);
456	return 0;
457}
458
459static int mt6660_i2c_probe(struct i2c_client *client)
460{
461	struct mt6660_chip *chip = NULL;
462	int ret;
463
464	dev_dbg(&client->dev, "%s\n", __func__);
465	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
466	if (!chip)
467		return -ENOMEM;
468	chip->i2c = client;
469	chip->dev = &client->dev;
470	mutex_init(&chip->io_lock);
471	i2c_set_clientdata(client, chip);
472
473	chip->regmap = devm_regmap_init(&client->dev,
474		NULL, chip, &mt6660_regmap_config);
475	if (IS_ERR(chip->regmap)) {
476		ret = PTR_ERR(chip->regmap);
477		dev_err(&client->dev, "failed to initialise regmap: %d\n", ret);
478		return ret;
479	}
480
481	/* chip reset first */
482	ret = _mt6660_chip_sw_reset(chip);
483	if (ret < 0) {
484		dev_err(chip->dev, "chip reset fail\n");
485		goto probe_fail;
486	}
487	/* chip power on */
488	ret = _mt6660_chip_power_on(chip, 1);
489	if (ret < 0) {
490		dev_err(chip->dev, "chip power on 2 fail\n");
491		goto probe_fail;
492	}
493	/* chip devid check */
494	ret = _mt6660_chip_id_check(chip);
495	if (ret < 0) {
496		dev_err(chip->dev, "chip id check fail\n");
497		goto probe_fail;
498	}
499	/* chip revision get */
500	ret = _mt6660_read_chip_revision(chip);
501	if (ret < 0) {
502		dev_err(chip->dev, "read chip revision fail\n");
503		goto probe_fail;
504	}
505	pm_runtime_set_active(chip->dev);
506	pm_runtime_enable(chip->dev);
507
508	ret = devm_snd_soc_register_component(chip->dev,
509					       &mt6660_component_driver,
510					       &mt6660_codec_dai, 1);
511	if (ret)
512		pm_runtime_disable(chip->dev);
513
514	return ret;
515
516probe_fail:
517	_mt6660_chip_power_on(chip, 0);
518	mutex_destroy(&chip->io_lock);
519	return ret;
520}
521
522static void mt6660_i2c_remove(struct i2c_client *client)
523{
524	struct mt6660_chip *chip = i2c_get_clientdata(client);
525
526	pm_runtime_disable(chip->dev);
527	pm_runtime_set_suspended(chip->dev);
528	mutex_destroy(&chip->io_lock);
529}
530
531static int mt6660_i2c_runtime_suspend(struct device *dev)
532{
533	struct mt6660_chip *chip = dev_get_drvdata(dev);
534
535	dev_dbg(dev, "enter low power mode\n");
536	return regmap_update_bits(chip->regmap,
537		MT6660_REG_SYSTEM_CTRL, 0x01, 0x01);
538}
539
540static int mt6660_i2c_runtime_resume(struct device *dev)
541{
542	struct mt6660_chip *chip = dev_get_drvdata(dev);
543
544	dev_dbg(dev, "exit low power mode\n");
545	return regmap_update_bits(chip->regmap,
546		MT6660_REG_SYSTEM_CTRL, 0x01, 0x00);
547}
548
549static const struct dev_pm_ops mt6660_dev_pm_ops = {
550	RUNTIME_PM_OPS(mt6660_i2c_runtime_suspend, mt6660_i2c_runtime_resume, NULL)
551};
552
553static const struct of_device_id __maybe_unused mt6660_of_id[] = {
554	{ .compatible = "mediatek,mt6660",},
555	{},
556};
557MODULE_DEVICE_TABLE(of, mt6660_of_id);
558
559static const struct i2c_device_id mt6660_i2c_id[] = {
560	{"mt6660" },
561	{},
562};
563MODULE_DEVICE_TABLE(i2c, mt6660_i2c_id);
564
565static struct i2c_driver mt6660_i2c_driver = {
566	.driver = {
567		.name = "mt6660",
568		.of_match_table = of_match_ptr(mt6660_of_id),
569		.pm = pm_ptr(&mt6660_dev_pm_ops),
570	},
571	.probe = mt6660_i2c_probe,
572	.remove = mt6660_i2c_remove,
573	.id_table = mt6660_i2c_id,
574};
575module_i2c_driver(mt6660_i2c_driver);
576
577MODULE_AUTHOR("Jeff Chang <jeff_chang@richtek.com>");
578MODULE_DESCRIPTION("MT6660 SPKAMP Driver");
579MODULE_LICENSE("GPL");
580MODULE_VERSION("1.0.8_G");