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