1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/module.h>
15#include <linux/moduleparam.h>
16#include <linux/init.h>
17#include <linux/delay.h>
18#include <linux/pm.h>
19#include <linux/i2c.h>
20#include <linux/spi/spi.h>
21#include <linux/regmap.h>
22#include <linux/regulator/consumer.h>
23#include <linux/slab.h>
24#include <linux/of_device.h>
25#include <sound/core.h>
26#include <sound/pcm.h>
27#include <sound/pcm_params.h>
28#include <sound/soc.h>
29#include <sound/initval.h>
30#include <sound/tlv.h>
31
32#include "wm8741.h"
33
34#define WM8741_NUM_SUPPLIES 2
35static const char *wm8741_supply_names[WM8741_NUM_SUPPLIES] = {
36 "AVDD",
37 "DVDD",
38};
39
40#define WM8741_NUM_RATES 6
41
42
43struct wm8741_priv {
44 struct wm8741_platform_data pdata;
45 struct regmap *regmap;
46 struct regulator_bulk_data supplies[WM8741_NUM_SUPPLIES];
47 unsigned int sysclk;
48 const struct snd_pcm_hw_constraint_list *sysclk_constraints;
49};
50
51static const struct reg_default wm8741_reg_defaults[] = {
52 { 0, 0x0000 },
53 { 1, 0x0000 },
54 { 2, 0x0000 },
55 { 3, 0x0000 },
56 { 4, 0x0000 },
57 { 5, 0x000A },
58 { 6, 0x0000 },
59 { 7, 0x0000 },
60 { 8, 0x0002 },
61 { 32, 0x0002 },
62};
63
64static int wm8741_reset(struct snd_soc_codec *codec)
65{
66 return snd_soc_write(codec, WM8741_RESET, 0);
67}
68
69static const DECLARE_TLV_DB_SCALE(dac_tlv_fine, -12700, 13, 0);
70static const DECLARE_TLV_DB_SCALE(dac_tlv, -12700, 400, 0);
71
72static const struct snd_kcontrol_new wm8741_snd_controls_stereo[] = {
73SOC_DOUBLE_R_TLV("Fine Playback Volume", WM8741_DACLLSB_ATTENUATION,
74 WM8741_DACRLSB_ATTENUATION, 1, 255, 1, dac_tlv_fine),
75SOC_DOUBLE_R_TLV("Playback Volume", WM8741_DACLMSB_ATTENUATION,
76 WM8741_DACRMSB_ATTENUATION, 0, 511, 1, dac_tlv),
77};
78
79static const struct snd_kcontrol_new wm8741_snd_controls_mono_left[] = {
80SOC_SINGLE_TLV("Fine Playback Volume", WM8741_DACLLSB_ATTENUATION,
81 1, 255, 1, dac_tlv_fine),
82SOC_SINGLE_TLV("Playback Volume", WM8741_DACLMSB_ATTENUATION,
83 0, 511, 1, dac_tlv),
84};
85
86static const struct snd_kcontrol_new wm8741_snd_controls_mono_right[] = {
87SOC_SINGLE_TLV("Fine Playback Volume", WM8741_DACRLSB_ATTENUATION,
88 1, 255, 1, dac_tlv_fine),
89SOC_SINGLE_TLV("Playback Volume", WM8741_DACRMSB_ATTENUATION,
90 0, 511, 1, dac_tlv),
91};
92
93static const struct snd_soc_dapm_widget wm8741_dapm_widgets[] = {
94SND_SOC_DAPM_DAC("DACL", "Playback", SND_SOC_NOPM, 0, 0),
95SND_SOC_DAPM_DAC("DACR", "Playback", SND_SOC_NOPM, 0, 0),
96SND_SOC_DAPM_OUTPUT("VOUTLP"),
97SND_SOC_DAPM_OUTPUT("VOUTLN"),
98SND_SOC_DAPM_OUTPUT("VOUTRP"),
99SND_SOC_DAPM_OUTPUT("VOUTRN"),
100};
101
102static const struct snd_soc_dapm_route wm8741_dapm_routes[] = {
103 { "VOUTLP", NULL, "DACL" },
104 { "VOUTLN", NULL, "DACL" },
105 { "VOUTRP", NULL, "DACR" },
106 { "VOUTRN", NULL, "DACR" },
107};
108
109static const unsigned int rates_11289[] = {
110 44100, 88200,
111};
112
113static const struct snd_pcm_hw_constraint_list constraints_11289 = {
114 .count = ARRAY_SIZE(rates_11289),
115 .list = rates_11289,
116};
117
118static const unsigned int rates_12288[] = {
119 32000, 48000, 96000,
120};
121
122static const struct snd_pcm_hw_constraint_list constraints_12288 = {
123 .count = ARRAY_SIZE(rates_12288),
124 .list = rates_12288,
125};
126
127static const unsigned int rates_16384[] = {
128 32000,
129};
130
131static const struct snd_pcm_hw_constraint_list constraints_16384 = {
132 .count = ARRAY_SIZE(rates_16384),
133 .list = rates_16384,
134};
135
136static const unsigned int rates_16934[] = {
137 44100, 88200,
138};
139
140static const struct snd_pcm_hw_constraint_list constraints_16934 = {
141 .count = ARRAY_SIZE(rates_16934),
142 .list = rates_16934,
143};
144
145static const unsigned int rates_18432[] = {
146 48000, 96000,
147};
148
149static const struct snd_pcm_hw_constraint_list constraints_18432 = {
150 .count = ARRAY_SIZE(rates_18432),
151 .list = rates_18432,
152};
153
154static const unsigned int rates_22579[] = {
155 44100, 88200, 176400
156};
157
158static const struct snd_pcm_hw_constraint_list constraints_22579 = {
159 .count = ARRAY_SIZE(rates_22579),
160 .list = rates_22579,
161};
162
163static const unsigned int rates_24576[] = {
164 32000, 48000, 96000, 192000
165};
166
167static const struct snd_pcm_hw_constraint_list constraints_24576 = {
168 .count = ARRAY_SIZE(rates_24576),
169 .list = rates_24576,
170};
171
172static const unsigned int rates_36864[] = {
173 48000, 96000, 192000
174};
175
176static const struct snd_pcm_hw_constraint_list constraints_36864 = {
177 .count = ARRAY_SIZE(rates_36864),
178 .list = rates_36864,
179};
180
181static int wm8741_startup(struct snd_pcm_substream *substream,
182 struct snd_soc_dai *dai)
183{
184 struct snd_soc_codec *codec = dai->codec;
185 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
186
187 if (wm8741->sysclk)
188 snd_pcm_hw_constraint_list(substream->runtime, 0,
189 SNDRV_PCM_HW_PARAM_RATE,
190 wm8741->sysclk_constraints);
191
192 return 0;
193}
194
195static int wm8741_hw_params(struct snd_pcm_substream *substream,
196 struct snd_pcm_hw_params *params,
197 struct snd_soc_dai *dai)
198{
199 struct snd_soc_codec *codec = dai->codec;
200 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
201 u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1FC;
202 int i;
203
204
205
206
207 if (!wm8741->sysclk) {
208 dev_err(codec->dev,
209 "No MCLK configured, call set_sysclk() on init or in hw_params\n");
210 return -EINVAL;
211 }
212
213
214 for (i = 0; i < wm8741->sysclk_constraints->count; i++) {
215 if (wm8741->sysclk_constraints->list[i] == params_rate(params))
216 break;
217 }
218
219 if (i == wm8741->sysclk_constraints->count) {
220 dev_err(codec->dev, "LRCLK %d unsupported with MCLK %d\n",
221 params_rate(params), wm8741->sysclk);
222 return -EINVAL;
223 }
224
225
226 switch (params_width(params)) {
227 case 16:
228 break;
229 case 20:
230 iface |= 0x0001;
231 break;
232 case 24:
233 iface |= 0x0002;
234 break;
235 case 32:
236 iface |= 0x0003;
237 break;
238 default:
239 dev_dbg(codec->dev, "wm8741_hw_params: Unsupported bit size param = %d",
240 params_width(params));
241 return -EINVAL;
242 }
243
244 dev_dbg(codec->dev, "wm8741_hw_params: bit size param = %d, rate param = %d",
245 params_width(params), params_rate(params));
246
247 snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface);
248 return 0;
249}
250
251static int wm8741_set_dai_sysclk(struct snd_soc_dai *codec_dai,
252 int clk_id, unsigned int freq, int dir)
253{
254 struct snd_soc_codec *codec = codec_dai->codec;
255 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
256
257 dev_dbg(codec->dev, "wm8741_set_dai_sysclk info: freq=%dHz\n", freq);
258
259 switch (freq) {
260 case 0:
261 wm8741->sysclk_constraints = NULL;
262 break;
263 case 11289600:
264 wm8741->sysclk_constraints = &constraints_11289;
265 break;
266 case 12288000:
267 wm8741->sysclk_constraints = &constraints_12288;
268 break;
269 case 16384000:
270 wm8741->sysclk_constraints = &constraints_16384;
271 break;
272 case 16934400:
273 wm8741->sysclk_constraints = &constraints_16934;
274 break;
275 case 18432000:
276 wm8741->sysclk_constraints = &constraints_18432;
277 break;
278 case 22579200:
279 case 33868800:
280 wm8741->sysclk_constraints = &constraints_22579;
281 break;
282 case 24576000:
283 wm8741->sysclk_constraints = &constraints_24576;
284 break;
285 case 36864000:
286 wm8741->sysclk_constraints = &constraints_36864;
287 break;
288 default:
289 return -EINVAL;
290 }
291
292 wm8741->sysclk = freq;
293 return 0;
294}
295
296static int wm8741_set_dai_fmt(struct snd_soc_dai *codec_dai,
297 unsigned int fmt)
298{
299 struct snd_soc_codec *codec = codec_dai->codec;
300 u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1C3;
301
302
303 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
304 case SND_SOC_DAIFMT_CBS_CFS:
305 break;
306 default:
307 return -EINVAL;
308 }
309
310
311 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
312 case SND_SOC_DAIFMT_I2S:
313 iface |= 0x0008;
314 break;
315 case SND_SOC_DAIFMT_RIGHT_J:
316 break;
317 case SND_SOC_DAIFMT_LEFT_J:
318 iface |= 0x0004;
319 break;
320 case SND_SOC_DAIFMT_DSP_A:
321 iface |= 0x000C;
322 break;
323 case SND_SOC_DAIFMT_DSP_B:
324 iface |= 0x001C;
325 break;
326 default:
327 return -EINVAL;
328 }
329
330
331 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
332 case SND_SOC_DAIFMT_NB_NF:
333 break;
334 case SND_SOC_DAIFMT_IB_IF:
335 iface |= 0x0010;
336 break;
337 case SND_SOC_DAIFMT_IB_NF:
338 iface |= 0x0020;
339 break;
340 case SND_SOC_DAIFMT_NB_IF:
341 iface |= 0x0030;
342 break;
343 default:
344 return -EINVAL;
345 }
346
347
348 dev_dbg(codec->dev, "wm8741_set_dai_fmt: Format=%x, Clock Inv=%x\n",
349 fmt & SND_SOC_DAIFMT_FORMAT_MASK,
350 ((fmt & SND_SOC_DAIFMT_INV_MASK)));
351
352 snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface);
353 return 0;
354}
355
356#define WM8741_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
357 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | \
358 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 | \
359 SNDRV_PCM_RATE_192000)
360
361#define WM8741_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
362 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
363
364static const struct snd_soc_dai_ops wm8741_dai_ops = {
365 .startup = wm8741_startup,
366 .hw_params = wm8741_hw_params,
367 .set_sysclk = wm8741_set_dai_sysclk,
368 .set_fmt = wm8741_set_dai_fmt,
369};
370
371static struct snd_soc_dai_driver wm8741_dai = {
372 .name = "wm8741",
373 .playback = {
374 .stream_name = "Playback",
375 .channels_min = 2,
376 .channels_max = 2,
377 .rates = WM8741_RATES,
378 .formats = WM8741_FORMATS,
379 },
380 .ops = &wm8741_dai_ops,
381};
382
383#ifdef CONFIG_PM
384static int wm8741_resume(struct snd_soc_codec *codec)
385{
386 snd_soc_cache_sync(codec);
387 return 0;
388}
389#else
390#define wm8741_resume NULL
391#endif
392
393static int wm8741_configure(struct snd_soc_codec *codec)
394{
395 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
396
397
398 switch (wm8741->pdata.diff_mode) {
399 case WM8741_DIFF_MODE_STEREO:
400 case WM8741_DIFF_MODE_STEREO_REVERSED:
401 case WM8741_DIFF_MODE_MONO_LEFT:
402 case WM8741_DIFF_MODE_MONO_RIGHT:
403 snd_soc_update_bits(codec, WM8741_MODE_CONTROL_2,
404 WM8741_DIFF_MASK,
405 wm8741->pdata.diff_mode << WM8741_DIFF_SHIFT);
406 break;
407 default:
408 return -EINVAL;
409 }
410
411
412 snd_soc_update_bits(codec, WM8741_DACLLSB_ATTENUATION,
413 WM8741_UPDATELL, WM8741_UPDATELL);
414 snd_soc_update_bits(codec, WM8741_DACLMSB_ATTENUATION,
415 WM8741_UPDATELM, WM8741_UPDATELM);
416 snd_soc_update_bits(codec, WM8741_DACRLSB_ATTENUATION,
417 WM8741_UPDATERL, WM8741_UPDATERL);
418 snd_soc_update_bits(codec, WM8741_DACRMSB_ATTENUATION,
419 WM8741_UPDATERM, WM8741_UPDATERM);
420
421 return 0;
422}
423
424static int wm8741_add_controls(struct snd_soc_codec *codec)
425{
426 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
427
428 switch (wm8741->pdata.diff_mode) {
429 case WM8741_DIFF_MODE_STEREO:
430 case WM8741_DIFF_MODE_STEREO_REVERSED:
431 snd_soc_add_codec_controls(codec,
432 wm8741_snd_controls_stereo,
433 ARRAY_SIZE(wm8741_snd_controls_stereo));
434 break;
435 case WM8741_DIFF_MODE_MONO_LEFT:
436 snd_soc_add_codec_controls(codec,
437 wm8741_snd_controls_mono_left,
438 ARRAY_SIZE(wm8741_snd_controls_mono_left));
439 break;
440 case WM8741_DIFF_MODE_MONO_RIGHT:
441 snd_soc_add_codec_controls(codec,
442 wm8741_snd_controls_mono_right,
443 ARRAY_SIZE(wm8741_snd_controls_mono_right));
444 break;
445 default:
446 return -EINVAL;
447 }
448
449 return 0;
450}
451
452static int wm8741_probe(struct snd_soc_codec *codec)
453{
454 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
455 int ret = 0;
456
457 ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies),
458 wm8741->supplies);
459 if (ret != 0) {
460 dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
461 goto err_get;
462 }
463
464 ret = wm8741_reset(codec);
465 if (ret < 0) {
466 dev_err(codec->dev, "Failed to issue reset\n");
467 goto err_enable;
468 }
469
470 ret = wm8741_configure(codec);
471 if (ret < 0) {
472 dev_err(codec->dev, "Failed to change default settings\n");
473 goto err_enable;
474 }
475
476 ret = wm8741_add_controls(codec);
477 if (ret < 0) {
478 dev_err(codec->dev, "Failed to add controls\n");
479 goto err_enable;
480 }
481
482 dev_dbg(codec->dev, "Successful registration\n");
483 return ret;
484
485err_enable:
486 regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
487err_get:
488 return ret;
489}
490
491static int wm8741_remove(struct snd_soc_codec *codec)
492{
493 struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
494
495 regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
496
497 return 0;
498}
499
500static struct snd_soc_codec_driver soc_codec_dev_wm8741 = {
501 .probe = wm8741_probe,
502 .remove = wm8741_remove,
503 .resume = wm8741_resume,
504
505 .dapm_widgets = wm8741_dapm_widgets,
506 .num_dapm_widgets = ARRAY_SIZE(wm8741_dapm_widgets),
507 .dapm_routes = wm8741_dapm_routes,
508 .num_dapm_routes = ARRAY_SIZE(wm8741_dapm_routes),
509};
510
511static const struct of_device_id wm8741_of_match[] = {
512 { .compatible = "wlf,wm8741", },
513 { }
514};
515MODULE_DEVICE_TABLE(of, wm8741_of_match);
516
517static const struct regmap_config wm8741_regmap = {
518 .reg_bits = 7,
519 .val_bits = 9,
520 .max_register = WM8741_MAX_REGISTER,
521
522 .reg_defaults = wm8741_reg_defaults,
523 .num_reg_defaults = ARRAY_SIZE(wm8741_reg_defaults),
524 .cache_type = REGCACHE_RBTREE,
525};
526
527static int wm8741_set_pdata(struct device *dev, struct wm8741_priv *wm8741)
528{
529 const struct wm8741_platform_data *pdata = dev_get_platdata(dev);
530 u32 diff_mode;
531
532 if (dev->of_node) {
533 if (of_property_read_u32(dev->of_node, "diff-mode", &diff_mode)
534 >= 0)
535 wm8741->pdata.diff_mode = diff_mode;
536 } else {
537 if (pdata != NULL)
538 memcpy(&wm8741->pdata, pdata, sizeof(wm8741->pdata));
539 }
540
541 return 0;
542}
543
544#if IS_ENABLED(CONFIG_I2C)
545static int wm8741_i2c_probe(struct i2c_client *i2c,
546 const struct i2c_device_id *id)
547{
548 struct wm8741_priv *wm8741;
549 int ret, i;
550
551 wm8741 = devm_kzalloc(&i2c->dev, sizeof(struct wm8741_priv),
552 GFP_KERNEL);
553 if (wm8741 == NULL)
554 return -ENOMEM;
555
556 for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
557 wm8741->supplies[i].supply = wm8741_supply_names[i];
558
559 ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8741->supplies),
560 wm8741->supplies);
561 if (ret != 0) {
562 dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
563 return ret;
564 }
565
566 wm8741->regmap = devm_regmap_init_i2c(i2c, &wm8741_regmap);
567 if (IS_ERR(wm8741->regmap)) {
568 ret = PTR_ERR(wm8741->regmap);
569 dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret);
570 return ret;
571 }
572
573 ret = wm8741_set_pdata(&i2c->dev, wm8741);
574 if (ret != 0) {
575 dev_err(&i2c->dev, "Failed to set pdata: %d\n", ret);
576 return ret;
577 }
578
579 i2c_set_clientdata(i2c, wm8741);
580
581 ret = snd_soc_register_codec(&i2c->dev,
582 &soc_codec_dev_wm8741, &wm8741_dai, 1);
583
584 return ret;
585}
586
587static int wm8741_i2c_remove(struct i2c_client *client)
588{
589 snd_soc_unregister_codec(&client->dev);
590 return 0;
591}
592
593static const struct i2c_device_id wm8741_i2c_id[] = {
594 { "wm8741", 0 },
595 { }
596};
597MODULE_DEVICE_TABLE(i2c, wm8741_i2c_id);
598
599static struct i2c_driver wm8741_i2c_driver = {
600 .driver = {
601 .name = "wm8741",
602 .of_match_table = wm8741_of_match,
603 },
604 .probe = wm8741_i2c_probe,
605 .remove = wm8741_i2c_remove,
606 .id_table = wm8741_i2c_id,
607};
608#endif
609
610#if defined(CONFIG_SPI_MASTER)
611static int wm8741_spi_probe(struct spi_device *spi)
612{
613 struct wm8741_priv *wm8741;
614 int ret, i;
615
616 wm8741 = devm_kzalloc(&spi->dev, sizeof(struct wm8741_priv),
617 GFP_KERNEL);
618 if (wm8741 == NULL)
619 return -ENOMEM;
620
621 for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
622 wm8741->supplies[i].supply = wm8741_supply_names[i];
623
624 ret = devm_regulator_bulk_get(&spi->dev, ARRAY_SIZE(wm8741->supplies),
625 wm8741->supplies);
626 if (ret != 0) {
627 dev_err(&spi->dev, "Failed to request supplies: %d\n", ret);
628 return ret;
629 }
630
631 wm8741->regmap = devm_regmap_init_spi(spi, &wm8741_regmap);
632 if (IS_ERR(wm8741->regmap)) {
633 ret = PTR_ERR(wm8741->regmap);
634 dev_err(&spi->dev, "Failed to init regmap: %d\n", ret);
635 return ret;
636 }
637
638 ret = wm8741_set_pdata(&spi->dev, wm8741);
639 if (ret != 0) {
640 dev_err(&spi->dev, "Failed to set pdata: %d\n", ret);
641 return ret;
642 }
643
644 spi_set_drvdata(spi, wm8741);
645
646 ret = snd_soc_register_codec(&spi->dev,
647 &soc_codec_dev_wm8741, &wm8741_dai, 1);
648 return ret;
649}
650
651static int wm8741_spi_remove(struct spi_device *spi)
652{
653 snd_soc_unregister_codec(&spi->dev);
654 return 0;
655}
656
657static struct spi_driver wm8741_spi_driver = {
658 .driver = {
659 .name = "wm8741",
660 .of_match_table = wm8741_of_match,
661 },
662 .probe = wm8741_spi_probe,
663 .remove = wm8741_spi_remove,
664};
665#endif
666
667static int __init wm8741_modinit(void)
668{
669 int ret = 0;
670
671#if IS_ENABLED(CONFIG_I2C)
672 ret = i2c_add_driver(&wm8741_i2c_driver);
673 if (ret != 0)
674 pr_err("Failed to register WM8741 I2C driver: %d\n", ret);
675#endif
676#if defined(CONFIG_SPI_MASTER)
677 ret = spi_register_driver(&wm8741_spi_driver);
678 if (ret != 0) {
679 printk(KERN_ERR "Failed to register wm8741 SPI driver: %d\n",
680 ret);
681 }
682#endif
683
684 return ret;
685}
686module_init(wm8741_modinit);
687
688static void __exit wm8741_exit(void)
689{
690#if defined(CONFIG_SPI_MASTER)
691 spi_unregister_driver(&wm8741_spi_driver);
692#endif
693#if IS_ENABLED(CONFIG_I2C)
694 i2c_del_driver(&wm8741_i2c_driver);
695#endif
696}
697module_exit(wm8741_exit);
698
699MODULE_DESCRIPTION("ASoC WM8741 driver");
700MODULE_AUTHOR("Ian Lartey <ian@opensource.wolfsonmicro.com>");
701MODULE_LICENSE("GPL");
702
