projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
ASoC: wm8962: Replace direct snd_soc_codec dapm field access
[deliverable/linux.git] / sound / soc / codecs / wm8731.c
... / ...
CommitLineData
1/*
2 * wm8731.c -- WM8731 ALSA SoC Audio driver
3 *
4 * Copyright 2005 Openedhand Ltd.
5 * Copyright 2006-12 Wolfson Microelectronics, plc
6 *
7 * Author: Richard Purdie <richard@openedhand.com>
8 *
9 * Based on wm8753.c by Liam Girdwood
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
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/* codec private data */
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 * wm8731 register cache
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 /* If we're using deemphasis select the nearest available sample
102 * rate.
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/* Output Mixer */
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/* Input mux */
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 /* output mixer */
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 /* outputs */
240 {"RHPOUT", NULL, "Output Mixer"},
241 {"ROUT", NULL, "Output Mixer"},
242 {"LHPOUT", NULL, "Output Mixer"},
243 {"LOUT", NULL, "Output Mixer"},
244
245 /* input mux */
246 {"Input Mux", "Line In", "Line Input"},
247 {"Input Mux", "Mic", "Mic Bias"},
248 {"ADC", NULL, "Input Mux"},
249
250 /* inputs */
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/* codec mclk clock divider coefficients */
266static const struct _coeff_div coeff_div[] = {
267 /* 48k */
268 {12288000, 48000, 256, 0x0, 0x0, 0x0},
269 {18432000, 48000, 384, 0x0, 0x1, 0x0},
270 {12000000, 48000, 250, 0x0, 0x0, 0x1},
271
272 /* 32k */
273 {12288000, 32000, 384, 0x6, 0x0, 0x0},
274 {18432000, 32000, 576, 0x6, 0x1, 0x0},
275 {12000000, 32000, 375, 0x6, 0x0, 0x1},
276
277 /* 8k */
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 /* 96k */
285 {12288000, 96000, 128, 0x7, 0x0, 0x0},
286 {18432000, 96000, 192, 0x7, 0x1, 0x0},
287 {12000000, 96000, 125, 0x7, 0x0, 0x1},
288
289 /* 44.1k */
290 {11289600, 44100, 256, 0x8, 0x0, 0x0},
291 {16934400, 44100, 384, 0x8, 0x1, 0x0},
292 {12000000, 44100, 272, 0x8, 0x1, 0x1},
293
294 /* 88.2k */
295 {11289600, 88200, 128, 0xf, 0x0, 0x0},
296 {16934400, 88200, 192, 0xf, 0x1, 0x0},
297 {12000000, 88200, 136, 0xf, 0x1, 0x1},
298};
299
300/* rates constraints */
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 /* bit size */
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 snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
391 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
392
393 switch (clk_id) {
394 case WM8731_SYSCLK_XTAL:
395 case WM8731_SYSCLK_MCLK:
396 if (wm8731->mclk && clk_set_rate(wm8731->mclk, freq))
397 return -EINVAL;
398 wm8731->sysclk_type = clk_id;
399 break;
400 default:
401 return -EINVAL;
402 }
403
404 switch (freq) {
405 case 0:
406 wm8731->constraints = NULL;
407 break;
408 case 12000000:
409 wm8731->constraints = &wm8731_constraints_12000000;
410 break;
411 case 12288000:
412 case 18432000:
413 wm8731->constraints = &wm8731_constraints_12288000_18432000;
414 break;
415 case 16934400:
416 case 11289600:
417 wm8731->constraints = &wm8731_constraints_11289600_16934400;
418 break;
419 default:
420 return -EINVAL;
421 }
422
423 wm8731->sysclk = freq;
424
425 snd_soc_dapm_sync(dapm);
426
427 return 0;
428}
429
430
431static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai,
432 unsigned int fmt)
433{
434 struct snd_soc_codec *codec = codec_dai->codec;
435 u16 iface = 0;
436
437 /* set master/slave audio interface */
438 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
439 case SND_SOC_DAIFMT_CBM_CFM:
440 iface |= 0x0040;
441 break;
442 case SND_SOC_DAIFMT_CBS_CFS:
443 break;
444 default:
445 return -EINVAL;
446 }
447
448 /* interface format */
449 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
450 case SND_SOC_DAIFMT_I2S:
451 iface |= 0x0002;
452 break;
453 case SND_SOC_DAIFMT_RIGHT_J:
454 break;
455 case SND_SOC_DAIFMT_LEFT_J:
456 iface |= 0x0001;
457 break;
458 case SND_SOC_DAIFMT_DSP_A:
459 iface |= 0x0013;
460 break;
461 case SND_SOC_DAIFMT_DSP_B:
462 iface |= 0x0003;
463 break;
464 default:
465 return -EINVAL;
466 }
467
468 /* clock inversion */
469 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
470 case SND_SOC_DAIFMT_NB_NF:
471 break;
472 case SND_SOC_DAIFMT_IB_IF:
473 iface |= 0x0090;
474 break;
475 case SND_SOC_DAIFMT_IB_NF:
476 iface |= 0x0080;
477 break;
478 case SND_SOC_DAIFMT_NB_IF:
479 iface |= 0x0010;
480 break;
481 default:
482 return -EINVAL;
483 }
484
485 /* set iface */
486 snd_soc_write(codec, WM8731_IFACE, iface);
487 return 0;
488}
489
490static int wm8731_set_bias_level(struct snd_soc_codec *codec,
491 enum snd_soc_bias_level level)
492{
493 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
494 int ret;
495 u16 reg;
496
497 switch (level) {
498 case SND_SOC_BIAS_ON:
499 if (wm8731->mclk)
500 clk_prepare_enable(wm8731->mclk);
501 break;
502 case SND_SOC_BIAS_PREPARE:
503 break;
504 case SND_SOC_BIAS_STANDBY:
505 if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) {
506 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies),
507 wm8731->supplies);
508 if (ret != 0)
509 return ret;
510
511 regcache_sync(wm8731->regmap);
512 }
513
514 /* Clear PWROFF, gate CLKOUT, everything else as-is */
515 reg = snd_soc_read(codec, WM8731_PWR) & 0xff7f;
516 snd_soc_write(codec, WM8731_PWR, reg | 0x0040);
517 break;
518 case SND_SOC_BIAS_OFF:
519 if (wm8731->mclk)
520 clk_disable_unprepare(wm8731->mclk);
521 snd_soc_write(codec, WM8731_PWR, 0xffff);
522 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies),
523 wm8731->supplies);
524 regcache_mark_dirty(wm8731->regmap);
525 break;
526 }
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 snd_soc_codec_force_bias_level(codec, SND_SOC_BIAS_STANDBY);
603
604 /* Latch the update bits */
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 /* Disable bypass path by default */
611 snd_soc_update_bits(codec, WM8731_APANA, 0x8, 0);
612
613 /* Regulators will have been enabled by bias management */
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/* power down chip */
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 /* CONFIG_SPI_MASTER */
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");
Linux kernel - Deliverables
This page took 0.026269 seconds and 5 git commands to generate.