1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/module.h>
17#include <linux/moduleparam.h>
18#include <linux/init.h>
19#include <linux/delay.h>
20#include <linux/pm.h>
21#include <linux/i2c.h>
22#include <linux/slab.h>
23#include <linux/regmap.h>
24#include <linux/regulator/consumer.h>
25#include <linux/spi/spi.h>
26#include <linux/of_device.h>
27#include <linux/mutex.h>
28#include <linux/clk.h>
29#include <sound/core.h>
30#include <sound/pcm.h>
31#include <sound/pcm_params.h>
32#include <sound/soc.h>
33#include <sound/initval.h>
34#include <sound/tlv.h>
35
36#include "wm8731.h"
37
38#define WM8731_NUM_SUPPLIES 4
39static const char *wm8731_supply_names[WM8731_NUM_SUPPLIES] = {
40 "AVDD",
41 "HPVDD",
42 "DCVDD",
43 "DBVDD",
44};
45
46
47struct wm8731_priv {
48 struct regmap *regmap;
49 struct clk *mclk;
50 struct regulator_bulk_data supplies[WM8731_NUM_SUPPLIES];
51 const struct snd_pcm_hw_constraint_list *constraints;
52 unsigned int sysclk;
53 int sysclk_type;
54 int playback_fs;
55 bool deemph;
56
57 struct mutex lock;
58};
59
60
61
62
63
64static const struct reg_default wm8731_reg_defaults[] = {
65 { 0, 0x0097 },
66 { 1, 0x0097 },
67 { 2, 0x0079 },
68 { 3, 0x0079 },
69 { 4, 0x000a },
70 { 5, 0x0008 },
71 { 6, 0x009f },
72 { 7, 0x000a },
73 { 8, 0x0000 },
74 { 9, 0x0000 },
75};
76
77static bool wm8731_volatile(struct device *dev, unsigned int reg)
78{
79 return reg == WM8731_RESET;
80}
81
82static bool wm8731_writeable(struct device *dev, unsigned int reg)
83{
84 return reg <= WM8731_RESET;
85}
86
87#define wm8731_reset(c) snd_soc_write(c, WM8731_RESET, 0)
88
89static const char *wm8731_input_select[] = {"Line In", "Mic"};
90
91static SOC_ENUM_SINGLE_DECL(wm8731_insel_enum,
92 WM8731_APANA, 2, wm8731_input_select);
93
94static int wm8731_deemph[] = { 0, 32000, 44100, 48000 };
95
96static int wm8731_set_deemph(struct snd_soc_codec *codec)
97{
98 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
99 int val, i, best;
100
101
102
103
104 if (wm8731->deemph) {
105 best = 1;
106 for (i = 2; i < ARRAY_SIZE(wm8731_deemph); i++) {
107 if (abs(wm8731_deemph[i] - wm8731->playback_fs) <
108 abs(wm8731_deemph[best] - wm8731->playback_fs))
109 best = i;
110 }
111
112 val = best << 1;
113 } else {
114 best = 0;
115 val = 0;
116 }
117
118 dev_dbg(codec->dev, "Set deemphasis %d (%dHz)\n",
119 best, wm8731_deemph[best]);
120
121 return snd_soc_update_bits(codec, WM8731_APDIGI, 0x6, val);
122}
123
124static int wm8731_get_deemph(struct snd_kcontrol *kcontrol,
125 struct snd_ctl_elem_value *ucontrol)
126{
127 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
128 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
129
130 ucontrol->value.integer.value[0] = wm8731->deemph;
131
132 return 0;
133}
134
135static int wm8731_put_deemph(struct snd_kcontrol *kcontrol,
136 struct snd_ctl_elem_value *ucontrol)
137{
138 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
139 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
140 int deemph = ucontrol->value.integer.value[0];
141 int ret = 0;
142
143 if (deemph > 1)
144 return -EINVAL;
145
146 mutex_lock(&wm8731->lock);
147 if (wm8731->deemph != deemph) {
148 wm8731->deemph = deemph;
149
150 wm8731_set_deemph(codec);
151
152 ret = 1;
153 }
154 mutex_unlock(&wm8731->lock);
155
156 return ret;
157}
158
159static const DECLARE_TLV_DB_SCALE(in_tlv, -3450, 150, 0);
160static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -1500, 300, 0);
161static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
162static const DECLARE_TLV_DB_SCALE(mic_tlv, 0, 2000, 0);
163
164static const struct snd_kcontrol_new wm8731_snd_controls[] = {
165
166SOC_DOUBLE_R_TLV("Master Playback Volume", WM8731_LOUT1V, WM8731_ROUT1V,
167 0, 127, 0, out_tlv),
168SOC_DOUBLE_R("Master Playback ZC Switch", WM8731_LOUT1V, WM8731_ROUT1V,
169 7, 1, 0),
170
171SOC_DOUBLE_R_TLV("Capture Volume", WM8731_LINVOL, WM8731_RINVOL, 0, 31, 0,
172 in_tlv),
173SOC_DOUBLE_R("Line Capture Switch", WM8731_LINVOL, WM8731_RINVOL, 7, 1, 1),
174
175SOC_SINGLE_TLV("Mic Boost Volume", WM8731_APANA, 0, 1, 0, mic_tlv),
176SOC_SINGLE("Mic Capture Switch", WM8731_APANA, 1, 1, 1),
177
178SOC_SINGLE_TLV("Sidetone Playback Volume", WM8731_APANA, 6, 3, 1,
179 sidetone_tlv),
180
181SOC_SINGLE("ADC High Pass Filter Switch", WM8731_APDIGI, 0, 1, 1),
182SOC_SINGLE("Store DC Offset Switch", WM8731_APDIGI, 4, 1, 0),
183
184SOC_SINGLE_BOOL_EXT("Playback Deemphasis Switch", 0,
185 wm8731_get_deemph, wm8731_put_deemph),
186};
187
188
189static const struct snd_kcontrol_new wm8731_output_mixer_controls[] = {
190SOC_DAPM_SINGLE("Line Bypass Switch", WM8731_APANA, 3, 1, 0),
191SOC_DAPM_SINGLE("Mic Sidetone Switch", WM8731_APANA, 5, 1, 0),
192SOC_DAPM_SINGLE("HiFi Playback Switch", WM8731_APANA, 4, 1, 0),
193};
194
195
196static const struct snd_kcontrol_new wm8731_input_mux_controls =
197SOC_DAPM_ENUM("Input Select", wm8731_insel_enum);
198
199static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = {
200SND_SOC_DAPM_SUPPLY("ACTIVE",WM8731_ACTIVE, 0, 0, NULL, 0),
201SND_SOC_DAPM_SUPPLY("OSC", WM8731_PWR, 5, 1, NULL, 0),
202SND_SOC_DAPM_MIXER("Output Mixer", WM8731_PWR, 4, 1,
203 &wm8731_output_mixer_controls[0],
204 ARRAY_SIZE(wm8731_output_mixer_controls)),
205SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8731_PWR, 3, 1),
206SND_SOC_DAPM_OUTPUT("LOUT"),
207SND_SOC_DAPM_OUTPUT("LHPOUT"),
208SND_SOC_DAPM_OUTPUT("ROUT"),
209SND_SOC_DAPM_OUTPUT("RHPOUT"),
210SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8731_PWR, 2, 1),
211SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &wm8731_input_mux_controls),
212SND_SOC_DAPM_PGA("Line Input", WM8731_PWR, 0, 1, NULL, 0),
213SND_SOC_DAPM_MICBIAS("Mic Bias", WM8731_PWR, 1, 1),
214SND_SOC_DAPM_INPUT("MICIN"),
215SND_SOC_DAPM_INPUT("RLINEIN"),
216SND_SOC_DAPM_INPUT("LLINEIN"),
217};
218
219static int wm8731_check_osc(struct snd_soc_dapm_widget *source,
220 struct snd_soc_dapm_widget *sink)
221{
222 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
223 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
224
225 return wm8731->sysclk_type == WM8731_SYSCLK_XTAL;
226}
227
228static const struct snd_soc_dapm_route wm8731_intercon[] = {
229 {"DAC", NULL, "OSC", wm8731_check_osc},
230 {"ADC", NULL, "OSC", wm8731_check_osc},
231 {"DAC", NULL, "ACTIVE"},
232 {"ADC", NULL, "ACTIVE"},
233
234
235 {"Output Mixer", "Line Bypass Switch", "Line Input"},
236 {"Output Mixer", "HiFi Playback Switch", "DAC"},
237 {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"},
238
239
240 {"RHPOUT", NULL, "Output Mixer"},
241 {"ROUT", NULL, "Output Mixer"},
242 {"LHPOUT", NULL, "Output Mixer"},
243 {"LOUT", NULL, "Output Mixer"},
244
245
246 {"Input Mux", "Line In", "Line Input"},
247 {"Input Mux", "Mic", "Mic Bias"},
248 {"ADC", NULL, "Input Mux"},
249
250
251 {"Line Input", NULL, "LLINEIN"},
252 {"Line Input", NULL, "RLINEIN"},
253 {"Mic Bias", NULL, "MICIN"},
254};
255
256struct _coeff_div {
257 u32 mclk;
258 u32 rate;
259 u16 fs;
260 u8 sr:4;
261 u8 bosr:1;
262 u8 usb:1;
263};
264
265
266static const struct _coeff_div coeff_div[] = {
267
268 {12288000, 48000, 256, 0x0, 0x0, 0x0},
269 {18432000, 48000, 384, 0x0, 0x1, 0x0},
270 {12000000, 48000, 250, 0x0, 0x0, 0x1},
271
272
273 {12288000, 32000, 384, 0x6, 0x0, 0x0},
274 {18432000, 32000, 576, 0x6, 0x1, 0x0},
275 {12000000, 32000, 375, 0x6, 0x0, 0x1},
276
277
278 {12288000, 8000, 1536, 0x3, 0x0, 0x0},
279 {18432000, 8000, 2304, 0x3, 0x1, 0x0},
280 {11289600, 8000, 1408, 0xb, 0x0, 0x0},
281 {16934400, 8000, 2112, 0xb, 0x1, 0x0},
282 {12000000, 8000, 1500, 0x3, 0x0, 0x1},
283
284
285 {12288000, 96000, 128, 0x7, 0x0, 0x0},
286 {18432000, 96000, 192, 0x7, 0x1, 0x0},
287 {12000000, 96000, 125, 0x7, 0x0, 0x1},
288
289
290 {11289600, 44100, 256, 0x8, 0x0, 0x0},
291 {16934400, 44100, 384, 0x8, 0x1, 0x0},
292 {12000000, 44100, 272, 0x8, 0x1, 0x1},
293
294
295 {11289600, 88200, 128, 0xf, 0x0, 0x0},
296 {16934400, 88200, 192, 0xf, 0x1, 0x0},
297 {12000000, 88200, 136, 0xf, 0x1, 0x1},
298};
299
300
301static const unsigned int wm8731_rates_12000000[] = {
302 8000, 32000, 44100, 48000, 96000, 88200,
303};
304
305static const unsigned int wm8731_rates_12288000_18432000[] = {
306 8000, 32000, 48000, 96000,
307};
308
309static const unsigned int wm8731_rates_11289600_16934400[] = {
310 8000, 44100, 88200,
311};
312
313static const struct snd_pcm_hw_constraint_list wm8731_constraints_12000000 = {
314 .list = wm8731_rates_12000000,
315 .count = ARRAY_SIZE(wm8731_rates_12000000),
316};
317
318static const
319struct snd_pcm_hw_constraint_list wm8731_constraints_12288000_18432000 = {
320 .list = wm8731_rates_12288000_18432000,
321 .count = ARRAY_SIZE(wm8731_rates_12288000_18432000),
322};
323
324static const
325struct snd_pcm_hw_constraint_list wm8731_constraints_11289600_16934400 = {
326 .list = wm8731_rates_11289600_16934400,
327 .count = ARRAY_SIZE(wm8731_rates_11289600_16934400),
328};
329
330static inline int get_coeff(int mclk, int rate)
331{
332 int i;
333
334 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
335 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
336 return i;
337 }
338 return 0;
339}
340
341static int wm8731_hw_params(struct snd_pcm_substream *substream,
342 struct snd_pcm_hw_params *params,
343 struct snd_soc_dai *dai)
344{
345 struct snd_soc_codec *codec = dai->codec;
346 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
347 u16 iface = snd_soc_read(codec, WM8731_IFACE) & 0xfff3;
348 int i = get_coeff(wm8731->sysclk, params_rate(params));
349 u16 srate = (coeff_div[i].sr << 2) |
350 (coeff_div[i].bosr << 1) | coeff_div[i].usb;
351
352 wm8731->playback_fs = params_rate(params);
353
354 snd_soc_write(codec, WM8731_SRATE, srate);
355
356
357 switch (params_width(params)) {
358 case 16:
359 break;
360 case 20:
361 iface |= 0x0004;
362 break;
363 case 24:
364 iface |= 0x0008;
365 break;
366 }
367
368 wm8731_set_deemph(codec);
369
370 snd_soc_write(codec, WM8731_IFACE, iface);
371 return 0;
372}
373
374static int wm8731_mute(struct snd_soc_dai *dai, int mute)
375{
376 struct snd_soc_codec *codec = dai->codec;
377 u16 mute_reg = snd_soc_read(codec, WM8731_APDIGI) & 0xfff7;
378
379 if (mute)
380 snd_soc_write(codec, WM8731_APDIGI, mute_reg | 0x8);
381 else
382 snd_soc_write(codec, WM8731_APDIGI, mute_reg);
383 return 0;
384}
385
386static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai,
387 int clk_id, unsigned int freq, int dir)
388{
389 struct snd_soc_codec *codec = codec_dai->codec;
390 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
391
392 switch (clk_id) {
393 case WM8731_SYSCLK_XTAL:
394 case WM8731_SYSCLK_MCLK:
395 if (wm8731->mclk && clk_set_rate(wm8731->mclk, freq))
396 return -EINVAL;
397 wm8731->sysclk_type = clk_id;
398 break;
399 default:
400 return -EINVAL;
401 }
402
403 switch (freq) {
404 case 0:
405 wm8731->constraints = NULL;
406 break;
407 case 12000000:
408 wm8731->constraints = &wm8731_constraints_12000000;
409 break;
410 case 12288000:
411 case 18432000:
412 wm8731->constraints = &wm8731_constraints_12288000_18432000;
413 break;
414 case 16934400:
415 case 11289600:
416 wm8731->constraints = &wm8731_constraints_11289600_16934400;
417 break;
418 default:
419 return -EINVAL;
420 }
421
422 wm8731->sysclk = freq;
423
424 snd_soc_dapm_sync(&codec->dapm);
425
426 return 0;
427}
428
429
430static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai,
431 unsigned int fmt)
432{
433 struct snd_soc_codec *codec = codec_dai->codec;
434 u16 iface = 0;
435
436
437 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
438 case SND_SOC_DAIFMT_CBM_CFM:
439 iface |= 0x0040;
440 break;
441 case SND_SOC_DAIFMT_CBS_CFS:
442 break;
443 default:
444 return -EINVAL;
445 }
446
447
448 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
449 case SND_SOC_DAIFMT_I2S:
450 iface |= 0x0002;
451 break;
452 case SND_SOC_DAIFMT_RIGHT_J:
453 break;
454 case SND_SOC_DAIFMT_LEFT_J:
455 iface |= 0x0001;
456 break;
457 case SND_SOC_DAIFMT_DSP_A:
458 iface |= 0x0013;
459 break;
460 case SND_SOC_DAIFMT_DSP_B:
461 iface |= 0x0003;
462 break;
463 default:
464 return -EINVAL;
465 }
466
467
468 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
469 case SND_SOC_DAIFMT_NB_NF:
470 break;
471 case SND_SOC_DAIFMT_IB_IF:
472 iface |= 0x0090;
473 break;
474 case SND_SOC_DAIFMT_IB_NF:
475 iface |= 0x0080;
476 break;
477 case SND_SOC_DAIFMT_NB_IF:
478 iface |= 0x0010;
479 break;
480 default:
481 return -EINVAL;
482 }
483
484
485 snd_soc_write(codec, WM8731_IFACE, iface);
486 return 0;
487}
488
489static int wm8731_set_bias_level(struct snd_soc_codec *codec,
490 enum snd_soc_bias_level level)
491{
492 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
493 int ret;
494 u16 reg;
495
496 switch (level) {
497 case SND_SOC_BIAS_ON:
498 if (wm8731->mclk)
499 clk_prepare_enable(wm8731->mclk);
500 break;
501 case SND_SOC_BIAS_PREPARE:
502 break;
503 case SND_SOC_BIAS_STANDBY:
504 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
505 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies),
506 wm8731->supplies);
507 if (ret != 0)
508 return ret;
509
510 regcache_sync(wm8731->regmap);
511 }
512
513
514 reg = snd_soc_read(codec, WM8731_PWR) & 0xff7f;
515 snd_soc_write(codec, WM8731_PWR, reg | 0x0040);
516 break;
517 case SND_SOC_BIAS_OFF:
518 if (wm8731->mclk)
519 clk_disable_unprepare(wm8731->mclk);
520 snd_soc_write(codec, WM8731_PWR, 0xffff);
521 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies),
522 wm8731->supplies);
523 regcache_mark_dirty(wm8731->regmap);
524 break;
525 }
526 codec->dapm.bias_level = level;
527 return 0;
528}
529
530static int wm8731_startup(struct snd_pcm_substream *substream,
531 struct snd_soc_dai *dai)
532{
533 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(dai->codec);
534
535 if (wm8731->constraints)
536 snd_pcm_hw_constraint_list(substream->runtime, 0,
537 SNDRV_PCM_HW_PARAM_RATE,
538 wm8731->constraints);
539
540 return 0;
541}
542
543#define WM8731_RATES SNDRV_PCM_RATE_8000_96000
544
545#define WM8731_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
546 SNDRV_PCM_FMTBIT_S24_LE)
547
548static const struct snd_soc_dai_ops wm8731_dai_ops = {
549 .startup = wm8731_startup,
550 .hw_params = wm8731_hw_params,
551 .digital_mute = wm8731_mute,
552 .set_sysclk = wm8731_set_dai_sysclk,
553 .set_fmt = wm8731_set_dai_fmt,
554};
555
556static struct snd_soc_dai_driver wm8731_dai = {
557 .name = "wm8731-hifi",
558 .playback = {
559 .stream_name = "Playback",
560 .channels_min = 1,
561 .channels_max = 2,
562 .rates = WM8731_RATES,
563 .formats = WM8731_FORMATS,},
564 .capture = {
565 .stream_name = "Capture",
566 .channels_min = 1,
567 .channels_max = 2,
568 .rates = WM8731_RATES,
569 .formats = WM8731_FORMATS,},
570 .ops = &wm8731_dai_ops,
571 .symmetric_rates = 1,
572};
573
574static int wm8731_probe(struct snd_soc_codec *codec)
575{
576 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
577 int ret = 0, i;
578
579 for (i = 0; i < ARRAY_SIZE(wm8731->supplies); i++)
580 wm8731->supplies[i].supply = wm8731_supply_names[i];
581
582 ret = devm_regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8731->supplies),
583 wm8731->supplies);
584 if (ret != 0) {
585 dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
586 return ret;
587 }
588
589 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies),
590 wm8731->supplies);
591 if (ret != 0) {
592 dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
593 return ret;
594 }
595
596 ret = wm8731_reset(codec);
597 if (ret < 0) {
598 dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
599 goto err_regulator_enable;
600 }
601
602 wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
603
604
605 snd_soc_update_bits(codec, WM8731_LOUT1V, 0x100, 0);
606 snd_soc_update_bits(codec, WM8731_ROUT1V, 0x100, 0);
607 snd_soc_update_bits(codec, WM8731_LINVOL, 0x100, 0);
608 snd_soc_update_bits(codec, WM8731_RINVOL, 0x100, 0);
609
610
611 snd_soc_update_bits(codec, WM8731_APANA, 0x8, 0);
612
613
614 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
615
616 return 0;
617
618err_regulator_enable:
619 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
620
621 return ret;
622}
623
624
625static int wm8731_remove(struct snd_soc_codec *codec)
626{
627 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
628
629 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
630
631 return 0;
632}
633
634static struct snd_soc_codec_driver soc_codec_dev_wm8731 = {
635 .probe = wm8731_probe,
636 .remove = wm8731_remove,
637 .set_bias_level = wm8731_set_bias_level,
638 .suspend_bias_off = true,
639
640 .dapm_widgets = wm8731_dapm_widgets,
641 .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets),
642 .dapm_routes = wm8731_intercon,
643 .num_dapm_routes = ARRAY_SIZE(wm8731_intercon),
644 .controls = wm8731_snd_controls,
645 .num_controls = ARRAY_SIZE(wm8731_snd_controls),
646};
647
648static const struct of_device_id wm8731_of_match[] = {
649 { .compatible = "wlf,wm8731", },
650 { }
651};
652
653MODULE_DEVICE_TABLE(of, wm8731_of_match);
654
655static const struct regmap_config wm8731_regmap = {
656 .reg_bits = 7,
657 .val_bits = 9,
658
659 .max_register = WM8731_RESET,
660 .volatile_reg = wm8731_volatile,
661 .writeable_reg = wm8731_writeable,
662
663 .cache_type = REGCACHE_RBTREE,
664 .reg_defaults = wm8731_reg_defaults,
665 .num_reg_defaults = ARRAY_SIZE(wm8731_reg_defaults),
666};
667
668#if defined(CONFIG_SPI_MASTER)
669static int wm8731_spi_probe(struct spi_device *spi)
670{
671 struct wm8731_priv *wm8731;
672 int ret;
673
674 wm8731 = devm_kzalloc(&spi->dev, sizeof(*wm8731), GFP_KERNEL);
675 if (wm8731 == NULL)
676 return -ENOMEM;
677
678 wm8731->mclk = devm_clk_get(&spi->dev, "mclk");
679 if (IS_ERR(wm8731->mclk)) {
680 ret = PTR_ERR(wm8731->mclk);
681 if (ret == -ENOENT) {
682 wm8731->mclk = NULL;
683 dev_warn(&spi->dev, "Assuming static MCLK\n");
684 } else {
685 dev_err(&spi->dev, "Failed to get MCLK: %d\n",
686 ret);
687 return ret;
688 }
689 }
690
691 mutex_init(&wm8731->lock);
692
693 wm8731->regmap = devm_regmap_init_spi(spi, &wm8731_regmap);
694 if (IS_ERR(wm8731->regmap)) {
695 ret = PTR_ERR(wm8731->regmap);
696 dev_err(&spi->dev, "Failed to allocate register map: %d\n",
697 ret);
698 return ret;
699 }
700
701 spi_set_drvdata(spi, wm8731);
702
703 ret = snd_soc_register_codec(&spi->dev,
704 &soc_codec_dev_wm8731, &wm8731_dai, 1);
705 if (ret != 0) {
706 dev_err(&spi->dev, "Failed to register CODEC: %d\n", ret);
707 return ret;
708 }
709
710 return 0;
711}
712
713static int wm8731_spi_remove(struct spi_device *spi)
714{
715 snd_soc_unregister_codec(&spi->dev);
716 return 0;
717}
718
719static struct spi_driver wm8731_spi_driver = {
720 .driver = {
721 .name = "wm8731",
722 .owner = THIS_MODULE,
723 .of_match_table = wm8731_of_match,
724 },
725 .probe = wm8731_spi_probe,
726 .remove = wm8731_spi_remove,
727};
728#endif
729
730#if IS_ENABLED(CONFIG_I2C)
731static int wm8731_i2c_probe(struct i2c_client *i2c,
732 const struct i2c_device_id *id)
733{
734 struct wm8731_priv *wm8731;
735 int ret;
736
737 wm8731 = devm_kzalloc(&i2c->dev, sizeof(struct wm8731_priv),
738 GFP_KERNEL);
739 if (wm8731 == NULL)
740 return -ENOMEM;
741
742 wm8731->mclk = devm_clk_get(&i2c->dev, "mclk");
743 if (IS_ERR(wm8731->mclk)) {
744 ret = PTR_ERR(wm8731->mclk);
745 if (ret == -ENOENT) {
746 wm8731->mclk = NULL;
747 dev_warn(&i2c->dev, "Assuming static MCLK\n");
748 } else {
749 dev_err(&i2c->dev, "Failed to get MCLK: %d\n",
750 ret);
751 return ret;
752 }
753 }
754
755 mutex_init(&wm8731->lock);
756
757 wm8731->regmap = devm_regmap_init_i2c(i2c, &wm8731_regmap);
758 if (IS_ERR(wm8731->regmap)) {
759 ret = PTR_ERR(wm8731->regmap);
760 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
761 ret);
762 return ret;
763 }
764
765 i2c_set_clientdata(i2c, wm8731);
766
767 ret = snd_soc_register_codec(&i2c->dev,
768 &soc_codec_dev_wm8731, &wm8731_dai, 1);
769 if (ret != 0) {
770 dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret);
771 return ret;
772 }
773
774 return 0;
775}
776
777static int wm8731_i2c_remove(struct i2c_client *client)
778{
779 snd_soc_unregister_codec(&client->dev);
780 return 0;
781}
782
783static const struct i2c_device_id wm8731_i2c_id[] = {
784 { "wm8731", 0 },
785 { }
786};
787MODULE_DEVICE_TABLE(i2c, wm8731_i2c_id);
788
789static struct i2c_driver wm8731_i2c_driver = {
790 .driver = {
791 .name = "wm8731",
792 .owner = THIS_MODULE,
793 .of_match_table = wm8731_of_match,
794 },
795 .probe = wm8731_i2c_probe,
796 .remove = wm8731_i2c_remove,
797 .id_table = wm8731_i2c_id,
798};
799#endif
800
801static int __init wm8731_modinit(void)
802{
803 int ret = 0;
804#if IS_ENABLED(CONFIG_I2C)
805 ret = i2c_add_driver(&wm8731_i2c_driver);
806 if (ret != 0) {
807 printk(KERN_ERR "Failed to register WM8731 I2C driver: %d\n",
808 ret);
809 }
810#endif
811#if defined(CONFIG_SPI_MASTER)
812 ret = spi_register_driver(&wm8731_spi_driver);
813 if (ret != 0) {
814 printk(KERN_ERR "Failed to register WM8731 SPI driver: %d\n",
815 ret);
816 }
817#endif
818 return ret;
819}
820module_init(wm8731_modinit);
821
822static void __exit wm8731_exit(void)
823{
824#if IS_ENABLED(CONFIG_I2C)
825 i2c_del_driver(&wm8731_i2c_driver);
826#endif
827#if defined(CONFIG_SPI_MASTER)
828 spi_unregister_driver(&wm8731_spi_driver);
829#endif
830}
831module_exit(wm8731_exit);
832
833MODULE_DESCRIPTION("ASoC WM8731 driver");
834MODULE_AUTHOR("Richard Purdie");
835MODULE_LICENSE("GPL");
836
