2 * wm8960.c -- WM8960 ALSA SoC Audio driver
4 * Copyright 2007-11 Wolfson Microelectronics, plc
6 * Author: Liam Girdwood
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
18 #include <linux/i2c.h>
19 #include <linux/slab.h>
20 #include <sound/core.h>
21 #include <sound/pcm.h>
22 #include <sound/pcm_params.h>
23 #include <sound/soc.h>
24 #include <sound/initval.h>
25 #include <sound/tlv.h>
26 #include <sound/wm8960.h>
31 #define WM8960_VMID_MASK 0x180
32 #define WM8960_VREF 0x40
35 #define WM8960_PWR2_LOUT1 0x40
36 #define WM8960_PWR2_ROUT1 0x20
37 #define WM8960_PWR2_OUT3 0x02
39 /* R28 - Anti-pop 1 */
40 #define WM8960_POBCTRL 0x80
41 #define WM8960_BUFDCOPEN 0x10
42 #define WM8960_BUFIOEN 0x08
43 #define WM8960_SOFT_ST 0x04
44 #define WM8960_HPSTBY 0x01
46 /* R29 - Anti-pop 2 */
47 #define WM8960_DISOP 0x40
48 #define WM8960_DRES_MASK 0x30
51 * wm8960 register cache
52 * We can't read the WM8960 register space when we are
53 * using 2 wire for device control, so we cache them instead.
55 static const struct reg_default wm8960_reg_defaults
[] = {
109 static bool wm8960_volatile(struct device
*dev
, unsigned int reg
)
120 struct regmap
*regmap
;
121 int (*set_bias_level
)(struct snd_soc_codec
*,
122 enum snd_soc_bias_level level
);
123 struct snd_soc_dapm_widget
*lout1
;
124 struct snd_soc_dapm_widget
*rout1
;
125 struct snd_soc_dapm_widget
*out3
;
130 #define wm8960_reset(c) snd_soc_write(c, WM8960_RESET, 0)
132 /* enumerated controls */
133 static const char *wm8960_polarity
[] = {"No Inversion", "Left Inverted",
134 "Right Inverted", "Stereo Inversion"};
135 static const char *wm8960_3d_upper_cutoff
[] = {"High", "Low"};
136 static const char *wm8960_3d_lower_cutoff
[] = {"Low", "High"};
137 static const char *wm8960_alcfunc
[] = {"Off", "Right", "Left", "Stereo"};
138 static const char *wm8960_alcmode
[] = {"ALC", "Limiter"};
140 static const struct soc_enum wm8960_enum
[] = {
141 SOC_ENUM_SINGLE(WM8960_DACCTL1
, 5, 4, wm8960_polarity
),
142 SOC_ENUM_SINGLE(WM8960_DACCTL2
, 5, 4, wm8960_polarity
),
143 SOC_ENUM_SINGLE(WM8960_3D
, 6, 2, wm8960_3d_upper_cutoff
),
144 SOC_ENUM_SINGLE(WM8960_3D
, 5, 2, wm8960_3d_lower_cutoff
),
145 SOC_ENUM_SINGLE(WM8960_ALC1
, 7, 4, wm8960_alcfunc
),
146 SOC_ENUM_SINGLE(WM8960_ALC3
, 8, 2, wm8960_alcmode
),
149 static const int deemph_settings
[] = { 0, 32000, 44100, 48000 };
151 static int wm8960_set_deemph(struct snd_soc_codec
*codec
)
153 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
156 /* If we're using deemphasis select the nearest available sample
159 if (wm8960
->deemph
) {
161 for (i
= 2; i
< ARRAY_SIZE(deemph_settings
); i
++) {
162 if (abs(deemph_settings
[i
] - wm8960
->playback_fs
) <
163 abs(deemph_settings
[best
] - wm8960
->playback_fs
))
172 dev_dbg(codec
->dev
, "Set deemphasis %d\n", val
);
174 return snd_soc_update_bits(codec
, WM8960_DACCTL1
,
178 static int wm8960_get_deemph(struct snd_kcontrol
*kcontrol
,
179 struct snd_ctl_elem_value
*ucontrol
)
181 struct snd_soc_codec
*codec
= snd_soc_kcontrol_codec(kcontrol
);
182 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
184 ucontrol
->value
.enumerated
.item
[0] = wm8960
->deemph
;
188 static int wm8960_put_deemph(struct snd_kcontrol
*kcontrol
,
189 struct snd_ctl_elem_value
*ucontrol
)
191 struct snd_soc_codec
*codec
= snd_soc_kcontrol_codec(kcontrol
);
192 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
193 int deemph
= ucontrol
->value
.enumerated
.item
[0];
198 wm8960
->deemph
= deemph
;
200 return wm8960_set_deemph(codec
);
203 static const DECLARE_TLV_DB_SCALE(adc_tlv
, -9700, 50, 0);
204 static const DECLARE_TLV_DB_SCALE(dac_tlv
, -12700, 50, 1);
205 static const DECLARE_TLV_DB_SCALE(bypass_tlv
, -2100, 300, 0);
206 static const DECLARE_TLV_DB_SCALE(out_tlv
, -12100, 100, 1);
207 static const DECLARE_TLV_DB_SCALE(boost_tlv
, -1200, 300, 1);
209 static const struct snd_kcontrol_new wm8960_snd_controls
[] = {
210 SOC_DOUBLE_R_TLV("Capture Volume", WM8960_LINVOL
, WM8960_RINVOL
,
212 SOC_DOUBLE_R("Capture Volume ZC Switch", WM8960_LINVOL
, WM8960_RINVOL
,
214 SOC_DOUBLE_R("Capture Switch", WM8960_LINVOL
, WM8960_RINVOL
,
217 SOC_SINGLE_TLV("Right Input Boost Mixer RINPUT3 Volume",
218 WM8960_INBMIX1
, 4, 7, 0, boost_tlv
),
219 SOC_SINGLE_TLV("Right Input Boost Mixer RINPUT2 Volume",
220 WM8960_INBMIX1
, 1, 7, 0, boost_tlv
),
221 SOC_SINGLE_TLV("Left Input Boost Mixer LINPUT3 Volume",
222 WM8960_INBMIX2
, 4, 7, 0, boost_tlv
),
223 SOC_SINGLE_TLV("Left Input Boost Mixer LINPUT2 Volume",
224 WM8960_INBMIX2
, 1, 7, 0, boost_tlv
),
226 SOC_DOUBLE_R_TLV("Playback Volume", WM8960_LDAC
, WM8960_RDAC
,
229 SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8960_LOUT1
, WM8960_ROUT1
,
231 SOC_DOUBLE_R("Headphone Playback ZC Switch", WM8960_LOUT1
, WM8960_ROUT1
,
234 SOC_DOUBLE_R_TLV("Speaker Playback Volume", WM8960_LOUT2
, WM8960_ROUT2
,
236 SOC_DOUBLE_R("Speaker Playback ZC Switch", WM8960_LOUT2
, WM8960_ROUT2
,
238 SOC_SINGLE("Speaker DC Volume", WM8960_CLASSD3
, 3, 5, 0),
239 SOC_SINGLE("Speaker AC Volume", WM8960_CLASSD3
, 0, 5, 0),
241 SOC_SINGLE("PCM Playback -6dB Switch", WM8960_DACCTL1
, 7, 1, 0),
242 SOC_ENUM("ADC Polarity", wm8960_enum
[0]),
243 SOC_SINGLE("ADC High Pass Filter Switch", WM8960_DACCTL1
, 0, 1, 0),
245 SOC_ENUM("DAC Polarity", wm8960_enum
[2]),
246 SOC_SINGLE_BOOL_EXT("DAC Deemphasis Switch", 0,
247 wm8960_get_deemph
, wm8960_put_deemph
),
249 SOC_ENUM("3D Filter Upper Cut-Off", wm8960_enum
[2]),
250 SOC_ENUM("3D Filter Lower Cut-Off", wm8960_enum
[3]),
251 SOC_SINGLE("3D Volume", WM8960_3D
, 1, 15, 0),
252 SOC_SINGLE("3D Switch", WM8960_3D
, 0, 1, 0),
254 SOC_ENUM("ALC Function", wm8960_enum
[4]),
255 SOC_SINGLE("ALC Max Gain", WM8960_ALC1
, 4, 7, 0),
256 SOC_SINGLE("ALC Target", WM8960_ALC1
, 0, 15, 1),
257 SOC_SINGLE("ALC Min Gain", WM8960_ALC2
, 4, 7, 0),
258 SOC_SINGLE("ALC Hold Time", WM8960_ALC2
, 0, 15, 0),
259 SOC_ENUM("ALC Mode", wm8960_enum
[5]),
260 SOC_SINGLE("ALC Decay", WM8960_ALC3
, 4, 15, 0),
261 SOC_SINGLE("ALC Attack", WM8960_ALC3
, 0, 15, 0),
263 SOC_SINGLE("Noise Gate Threshold", WM8960_NOISEG
, 3, 31, 0),
264 SOC_SINGLE("Noise Gate Switch", WM8960_NOISEG
, 0, 1, 0),
266 SOC_DOUBLE_R_TLV("ADC PCM Capture Volume", WM8960_LADC
, WM8960_RADC
,
269 SOC_SINGLE_TLV("Left Output Mixer Boost Bypass Volume",
270 WM8960_BYPASS1
, 4, 7, 1, bypass_tlv
),
271 SOC_SINGLE_TLV("Left Output Mixer LINPUT3 Volume",
272 WM8960_LOUTMIX
, 4, 7, 1, bypass_tlv
),
273 SOC_SINGLE_TLV("Right Output Mixer Boost Bypass Volume",
274 WM8960_BYPASS2
, 4, 7, 1, bypass_tlv
),
275 SOC_SINGLE_TLV("Right Output Mixer RINPUT3 Volume",
276 WM8960_ROUTMIX
, 4, 7, 1, bypass_tlv
),
279 static const struct snd_kcontrol_new wm8960_lin_boost
[] = {
280 SOC_DAPM_SINGLE("LINPUT2 Switch", WM8960_LINPATH
, 6, 1, 0),
281 SOC_DAPM_SINGLE("LINPUT3 Switch", WM8960_LINPATH
, 7, 1, 0),
282 SOC_DAPM_SINGLE("LINPUT1 Switch", WM8960_LINPATH
, 8, 1, 0),
285 static const struct snd_kcontrol_new wm8960_lin
[] = {
286 SOC_DAPM_SINGLE("Boost Switch", WM8960_LINPATH
, 3, 1, 0),
289 static const struct snd_kcontrol_new wm8960_rin_boost
[] = {
290 SOC_DAPM_SINGLE("RINPUT2 Switch", WM8960_RINPATH
, 6, 1, 0),
291 SOC_DAPM_SINGLE("RINPUT3 Switch", WM8960_RINPATH
, 7, 1, 0),
292 SOC_DAPM_SINGLE("RINPUT1 Switch", WM8960_RINPATH
, 8, 1, 0),
295 static const struct snd_kcontrol_new wm8960_rin
[] = {
296 SOC_DAPM_SINGLE("Boost Switch", WM8960_RINPATH
, 3, 1, 0),
299 static const struct snd_kcontrol_new wm8960_loutput_mixer
[] = {
300 SOC_DAPM_SINGLE("PCM Playback Switch", WM8960_LOUTMIX
, 8, 1, 0),
301 SOC_DAPM_SINGLE("LINPUT3 Switch", WM8960_LOUTMIX
, 7, 1, 0),
302 SOC_DAPM_SINGLE("Boost Bypass Switch", WM8960_BYPASS1
, 7, 1, 0),
305 static const struct snd_kcontrol_new wm8960_routput_mixer
[] = {
306 SOC_DAPM_SINGLE("PCM Playback Switch", WM8960_ROUTMIX
, 8, 1, 0),
307 SOC_DAPM_SINGLE("RINPUT3 Switch", WM8960_ROUTMIX
, 7, 1, 0),
308 SOC_DAPM_SINGLE("Boost Bypass Switch", WM8960_BYPASS2
, 7, 1, 0),
311 static const struct snd_kcontrol_new wm8960_mono_out
[] = {
312 SOC_DAPM_SINGLE("Left Switch", WM8960_MONOMIX1
, 7, 1, 0),
313 SOC_DAPM_SINGLE("Right Switch", WM8960_MONOMIX2
, 7, 1, 0),
316 static const struct snd_soc_dapm_widget wm8960_dapm_widgets
[] = {
317 SND_SOC_DAPM_INPUT("LINPUT1"),
318 SND_SOC_DAPM_INPUT("RINPUT1"),
319 SND_SOC_DAPM_INPUT("LINPUT2"),
320 SND_SOC_DAPM_INPUT("RINPUT2"),
321 SND_SOC_DAPM_INPUT("LINPUT3"),
322 SND_SOC_DAPM_INPUT("RINPUT3"),
324 SND_SOC_DAPM_SUPPLY("MICB", WM8960_POWER1
, 1, 0, NULL
, 0),
326 SND_SOC_DAPM_MIXER("Left Boost Mixer", WM8960_POWER1
, 5, 0,
327 wm8960_lin_boost
, ARRAY_SIZE(wm8960_lin_boost
)),
328 SND_SOC_DAPM_MIXER("Right Boost Mixer", WM8960_POWER1
, 4, 0,
329 wm8960_rin_boost
, ARRAY_SIZE(wm8960_rin_boost
)),
331 SND_SOC_DAPM_MIXER("Left Input Mixer", WM8960_POWER3
, 5, 0,
332 wm8960_lin
, ARRAY_SIZE(wm8960_lin
)),
333 SND_SOC_DAPM_MIXER("Right Input Mixer", WM8960_POWER3
, 4, 0,
334 wm8960_rin
, ARRAY_SIZE(wm8960_rin
)),
336 SND_SOC_DAPM_ADC("Left ADC", "Capture", WM8960_POWER1
, 3, 0),
337 SND_SOC_DAPM_ADC("Right ADC", "Capture", WM8960_POWER1
, 2, 0),
339 SND_SOC_DAPM_DAC("Left DAC", "Playback", WM8960_POWER2
, 8, 0),
340 SND_SOC_DAPM_DAC("Right DAC", "Playback", WM8960_POWER2
, 7, 0),
342 SND_SOC_DAPM_MIXER("Left Output Mixer", WM8960_POWER3
, 3, 0,
343 &wm8960_loutput_mixer
[0],
344 ARRAY_SIZE(wm8960_loutput_mixer
)),
345 SND_SOC_DAPM_MIXER("Right Output Mixer", WM8960_POWER3
, 2, 0,
346 &wm8960_routput_mixer
[0],
347 ARRAY_SIZE(wm8960_routput_mixer
)),
349 SND_SOC_DAPM_PGA("LOUT1 PGA", WM8960_POWER2
, 6, 0, NULL
, 0),
350 SND_SOC_DAPM_PGA("ROUT1 PGA", WM8960_POWER2
, 5, 0, NULL
, 0),
352 SND_SOC_DAPM_PGA("Left Speaker PGA", WM8960_POWER2
, 4, 0, NULL
, 0),
353 SND_SOC_DAPM_PGA("Right Speaker PGA", WM8960_POWER2
, 3, 0, NULL
, 0),
355 SND_SOC_DAPM_PGA("Right Speaker Output", WM8960_CLASSD1
, 7, 0, NULL
, 0),
356 SND_SOC_DAPM_PGA("Left Speaker Output", WM8960_CLASSD1
, 6, 0, NULL
, 0),
358 SND_SOC_DAPM_OUTPUT("SPK_LP"),
359 SND_SOC_DAPM_OUTPUT("SPK_LN"),
360 SND_SOC_DAPM_OUTPUT("HP_L"),
361 SND_SOC_DAPM_OUTPUT("HP_R"),
362 SND_SOC_DAPM_OUTPUT("SPK_RP"),
363 SND_SOC_DAPM_OUTPUT("SPK_RN"),
364 SND_SOC_DAPM_OUTPUT("OUT3"),
367 static const struct snd_soc_dapm_widget wm8960_dapm_widgets_out3
[] = {
368 SND_SOC_DAPM_MIXER("Mono Output Mixer", WM8960_POWER2
, 1, 0,
370 ARRAY_SIZE(wm8960_mono_out
)),
373 /* Represent OUT3 as a PGA so that it gets turned on with LOUT1/ROUT1 */
374 static const struct snd_soc_dapm_widget wm8960_dapm_widgets_capless
[] = {
375 SND_SOC_DAPM_PGA("OUT3 VMID", WM8960_POWER2
, 1, 0, NULL
, 0),
378 static const struct snd_soc_dapm_route audio_paths
[] = {
379 { "Left Boost Mixer", "LINPUT1 Switch", "LINPUT1" },
380 { "Left Boost Mixer", "LINPUT2 Switch", "LINPUT2" },
381 { "Left Boost Mixer", "LINPUT3 Switch", "LINPUT3" },
383 { "Left Input Mixer", "Boost Switch", "Left Boost Mixer", },
384 { "Left Input Mixer", NULL
, "LINPUT1", }, /* Really Boost Switch */
385 { "Left Input Mixer", NULL
, "LINPUT2" },
386 { "Left Input Mixer", NULL
, "LINPUT3" },
388 { "Right Boost Mixer", "RINPUT1 Switch", "RINPUT1" },
389 { "Right Boost Mixer", "RINPUT2 Switch", "RINPUT2" },
390 { "Right Boost Mixer", "RINPUT3 Switch", "RINPUT3" },
392 { "Right Input Mixer", "Boost Switch", "Right Boost Mixer", },
393 { "Right Input Mixer", NULL
, "RINPUT1", }, /* Really Boost Switch */
394 { "Right Input Mixer", NULL
, "RINPUT2" },
395 { "Right Input Mixer", NULL
, "LINPUT3" },
397 { "Left ADC", NULL
, "Left Input Mixer" },
398 { "Right ADC", NULL
, "Right Input Mixer" },
400 { "Left Output Mixer", "LINPUT3 Switch", "LINPUT3" },
401 { "Left Output Mixer", "Boost Bypass Switch", "Left Boost Mixer"} ,
402 { "Left Output Mixer", "PCM Playback Switch", "Left DAC" },
404 { "Right Output Mixer", "RINPUT3 Switch", "RINPUT3" },
405 { "Right Output Mixer", "Boost Bypass Switch", "Right Boost Mixer" } ,
406 { "Right Output Mixer", "PCM Playback Switch", "Right DAC" },
408 { "LOUT1 PGA", NULL
, "Left Output Mixer" },
409 { "ROUT1 PGA", NULL
, "Right Output Mixer" },
411 { "HP_L", NULL
, "LOUT1 PGA" },
412 { "HP_R", NULL
, "ROUT1 PGA" },
414 { "Left Speaker PGA", NULL
, "Left Output Mixer" },
415 { "Right Speaker PGA", NULL
, "Right Output Mixer" },
417 { "Left Speaker Output", NULL
, "Left Speaker PGA" },
418 { "Right Speaker Output", NULL
, "Right Speaker PGA" },
420 { "SPK_LN", NULL
, "Left Speaker Output" },
421 { "SPK_LP", NULL
, "Left Speaker Output" },
422 { "SPK_RN", NULL
, "Right Speaker Output" },
423 { "SPK_RP", NULL
, "Right Speaker Output" },
426 static const struct snd_soc_dapm_route audio_paths_out3
[] = {
427 { "Mono Output Mixer", "Left Switch", "Left Output Mixer" },
428 { "Mono Output Mixer", "Right Switch", "Right Output Mixer" },
430 { "OUT3", NULL
, "Mono Output Mixer", }
433 static const struct snd_soc_dapm_route audio_paths_capless
[] = {
434 { "HP_L", NULL
, "OUT3 VMID" },
435 { "HP_R", NULL
, "OUT3 VMID" },
437 { "OUT3 VMID", NULL
, "Left Output Mixer" },
438 { "OUT3 VMID", NULL
, "Right Output Mixer" },
441 static int wm8960_add_widgets(struct snd_soc_codec
*codec
)
443 struct wm8960_data
*pdata
= codec
->dev
->platform_data
;
444 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
445 struct snd_soc_dapm_context
*dapm
= &codec
->dapm
;
446 struct snd_soc_dapm_widget
*w
;
448 snd_soc_dapm_new_controls(dapm
, wm8960_dapm_widgets
,
449 ARRAY_SIZE(wm8960_dapm_widgets
));
451 snd_soc_dapm_add_routes(dapm
, audio_paths
, ARRAY_SIZE(audio_paths
));
453 /* In capless mode OUT3 is used to provide VMID for the
454 * headphone outputs, otherwise it is used as a mono mixer.
456 if (pdata
&& pdata
->capless
) {
457 snd_soc_dapm_new_controls(dapm
, wm8960_dapm_widgets_capless
,
458 ARRAY_SIZE(wm8960_dapm_widgets_capless
));
460 snd_soc_dapm_add_routes(dapm
, audio_paths_capless
,
461 ARRAY_SIZE(audio_paths_capless
));
463 snd_soc_dapm_new_controls(dapm
, wm8960_dapm_widgets_out3
,
464 ARRAY_SIZE(wm8960_dapm_widgets_out3
));
466 snd_soc_dapm_add_routes(dapm
, audio_paths_out3
,
467 ARRAY_SIZE(audio_paths_out3
));
470 /* We need to power up the headphone output stage out of
471 * sequence for capless mode. To save scanning the widget
472 * list each time to find the desired power state do so now
473 * and save the result.
475 list_for_each_entry(w
, &codec
->component
.card
->widgets
, list
) {
476 if (w
->dapm
!= &codec
->dapm
)
478 if (strcmp(w
->name
, "LOUT1 PGA") == 0)
480 if (strcmp(w
->name
, "ROUT1 PGA") == 0)
482 if (strcmp(w
->name
, "OUT3 VMID") == 0)
489 static int wm8960_set_dai_fmt(struct snd_soc_dai
*codec_dai
,
492 struct snd_soc_codec
*codec
= codec_dai
->codec
;
495 /* set master/slave audio interface */
496 switch (fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
497 case SND_SOC_DAIFMT_CBM_CFM
:
500 case SND_SOC_DAIFMT_CBS_CFS
:
506 /* interface format */
507 switch (fmt
& SND_SOC_DAIFMT_FORMAT_MASK
) {
508 case SND_SOC_DAIFMT_I2S
:
511 case SND_SOC_DAIFMT_RIGHT_J
:
513 case SND_SOC_DAIFMT_LEFT_J
:
516 case SND_SOC_DAIFMT_DSP_A
:
519 case SND_SOC_DAIFMT_DSP_B
:
526 /* clock inversion */
527 switch (fmt
& SND_SOC_DAIFMT_INV_MASK
) {
528 case SND_SOC_DAIFMT_NB_NF
:
530 case SND_SOC_DAIFMT_IB_IF
:
533 case SND_SOC_DAIFMT_IB_NF
:
536 case SND_SOC_DAIFMT_NB_IF
:
544 snd_soc_write(codec
, WM8960_IFACE1
, iface
);
563 static int wm8960_hw_params(struct snd_pcm_substream
*substream
,
564 struct snd_pcm_hw_params
*params
,
565 struct snd_soc_dai
*dai
)
567 struct snd_soc_codec
*codec
= dai
->codec
;
568 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
569 u16 iface
= snd_soc_read(codec
, WM8960_IFACE1
) & 0xfff3;
573 switch (params_width(params
)) {
583 dev_err(codec
->dev
, "unsupported width %d\n",
584 params_width(params
));
588 /* Update filters for the new rate */
589 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
590 wm8960
->playback_fs
= params_rate(params
);
591 wm8960_set_deemph(codec
);
593 for (i
= 0; i
< ARRAY_SIZE(alc_rates
); i
++)
594 if (alc_rates
[i
].rate
== params_rate(params
))
595 snd_soc_update_bits(codec
,
601 snd_soc_write(codec
, WM8960_IFACE1
, iface
);
605 static int wm8960_mute(struct snd_soc_dai
*dai
, int mute
)
607 struct snd_soc_codec
*codec
= dai
->codec
;
610 snd_soc_update_bits(codec
, WM8960_DACCTL1
, 0x8, 0x8);
612 snd_soc_update_bits(codec
, WM8960_DACCTL1
, 0x8, 0);
616 static int wm8960_set_bias_level_out3(struct snd_soc_codec
*codec
,
617 enum snd_soc_bias_level level
)
619 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
622 case SND_SOC_BIAS_ON
:
625 case SND_SOC_BIAS_PREPARE
:
626 /* Set VMID to 2x50k */
627 snd_soc_update_bits(codec
, WM8960_POWER1
, 0x180, 0x80);
630 case SND_SOC_BIAS_STANDBY
:
631 if (codec
->dapm
.bias_level
== SND_SOC_BIAS_OFF
) {
632 regcache_sync(wm8960
->regmap
);
634 /* Enable anti-pop features */
635 snd_soc_write(codec
, WM8960_APOP1
,
636 WM8960_POBCTRL
| WM8960_SOFT_ST
|
637 WM8960_BUFDCOPEN
| WM8960_BUFIOEN
);
639 /* Enable & ramp VMID at 2x50k */
640 snd_soc_update_bits(codec
, WM8960_POWER1
, 0x80, 0x80);
644 snd_soc_update_bits(codec
, WM8960_POWER1
, WM8960_VREF
,
647 /* Disable anti-pop features */
648 snd_soc_write(codec
, WM8960_APOP1
, WM8960_BUFIOEN
);
651 /* Set VMID to 2x250k */
652 snd_soc_update_bits(codec
, WM8960_POWER1
, 0x180, 0x100);
655 case SND_SOC_BIAS_OFF
:
656 /* Enable anti-pop features */
657 snd_soc_write(codec
, WM8960_APOP1
,
658 WM8960_POBCTRL
| WM8960_SOFT_ST
|
659 WM8960_BUFDCOPEN
| WM8960_BUFIOEN
);
661 /* Disable VMID and VREF, let them discharge */
662 snd_soc_write(codec
, WM8960_POWER1
, 0);
667 codec
->dapm
.bias_level
= level
;
672 static int wm8960_set_bias_level_capless(struct snd_soc_codec
*codec
,
673 enum snd_soc_bias_level level
)
675 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
679 case SND_SOC_BIAS_ON
:
682 case SND_SOC_BIAS_PREPARE
:
683 switch (codec
->dapm
.bias_level
) {
684 case SND_SOC_BIAS_STANDBY
:
685 /* Enable anti pop mode */
686 snd_soc_update_bits(codec
, WM8960_APOP1
,
687 WM8960_POBCTRL
| WM8960_SOFT_ST
|
689 WM8960_POBCTRL
| WM8960_SOFT_ST
|
692 /* Enable LOUT1, ROUT1 and OUT3 if they're enabled */
694 if (wm8960
->lout1
&& wm8960
->lout1
->power
)
695 reg
|= WM8960_PWR2_LOUT1
;
696 if (wm8960
->rout1
&& wm8960
->rout1
->power
)
697 reg
|= WM8960_PWR2_ROUT1
;
698 if (wm8960
->out3
&& wm8960
->out3
->power
)
699 reg
|= WM8960_PWR2_OUT3
;
700 snd_soc_update_bits(codec
, WM8960_POWER2
,
703 WM8960_PWR2_OUT3
, reg
);
705 /* Enable VMID at 2*50k */
706 snd_soc_update_bits(codec
, WM8960_POWER1
,
707 WM8960_VMID_MASK
, 0x80);
713 snd_soc_update_bits(codec
, WM8960_POWER1
,
714 WM8960_VREF
, WM8960_VREF
);
719 case SND_SOC_BIAS_ON
:
720 /* Enable anti-pop mode */
721 snd_soc_update_bits(codec
, WM8960_APOP1
,
722 WM8960_POBCTRL
| WM8960_SOFT_ST
|
724 WM8960_POBCTRL
| WM8960_SOFT_ST
|
727 /* Disable VMID and VREF */
728 snd_soc_update_bits(codec
, WM8960_POWER1
,
729 WM8960_VREF
| WM8960_VMID_MASK
, 0);
732 case SND_SOC_BIAS_OFF
:
733 regcache_sync(wm8960
->regmap
);
740 case SND_SOC_BIAS_STANDBY
:
741 switch (codec
->dapm
.bias_level
) {
742 case SND_SOC_BIAS_PREPARE
:
743 /* Disable HP discharge */
744 snd_soc_update_bits(codec
, WM8960_APOP2
,
745 WM8960_DISOP
| WM8960_DRES_MASK
,
748 /* Disable anti-pop features */
749 snd_soc_update_bits(codec
, WM8960_APOP1
,
750 WM8960_POBCTRL
| WM8960_SOFT_ST
|
752 WM8960_POBCTRL
| WM8960_SOFT_ST
|
761 case SND_SOC_BIAS_OFF
:
765 codec
->dapm
.bias_level
= level
;
777 /* The size in bits of the pll divide multiplied by 10
778 * to allow rounding later */
779 #define FIXED_PLL_SIZE ((1 << 24) * 10)
781 static int pll_factors(unsigned int source
, unsigned int target
,
782 struct _pll_div
*pll_div
)
784 unsigned long long Kpart
;
785 unsigned int K
, Ndiv
, Nmod
;
787 pr_debug("WM8960 PLL: setting %dHz->%dHz\n", source
, target
);
789 /* Scale up target to PLL operating frequency */
792 Ndiv
= target
/ source
;
795 pll_div
->pre_div
= 1;
796 Ndiv
= target
/ source
;
798 pll_div
->pre_div
= 0;
800 if ((Ndiv
< 6) || (Ndiv
> 12)) {
801 pr_err("WM8960 PLL: Unsupported N=%d\n", Ndiv
);
806 Nmod
= target
% source
;
807 Kpart
= FIXED_PLL_SIZE
* (long long)Nmod
;
809 do_div(Kpart
, source
);
811 K
= Kpart
& 0xFFFFFFFF;
813 /* Check if we need to round */
817 /* Move down to proper range now rounding is done */
822 pr_debug("WM8960 PLL: N=%x K=%x pre_div=%d\n",
823 pll_div
->n
, pll_div
->k
, pll_div
->pre_div
);
828 static int wm8960_set_dai_pll(struct snd_soc_dai
*codec_dai
, int pll_id
,
829 int source
, unsigned int freq_in
, unsigned int freq_out
)
831 struct snd_soc_codec
*codec
= codec_dai
->codec
;
833 static struct _pll_div pll_div
;
836 if (freq_in
&& freq_out
) {
837 ret
= pll_factors(freq_in
, freq_out
, &pll_div
);
842 /* Disable the PLL: even if we are changing the frequency the
843 * PLL needs to be disabled while we do so. */
844 snd_soc_update_bits(codec
, WM8960_CLOCK1
, 0x1, 0);
845 snd_soc_update_bits(codec
, WM8960_POWER2
, 0x1, 0);
847 if (!freq_in
|| !freq_out
)
850 reg
= snd_soc_read(codec
, WM8960_PLL1
) & ~0x3f;
851 reg
|= pll_div
.pre_div
<< 4;
857 snd_soc_write(codec
, WM8960_PLL2
, (pll_div
.k
>> 16) & 0xff);
858 snd_soc_write(codec
, WM8960_PLL3
, (pll_div
.k
>> 8) & 0xff);
859 snd_soc_write(codec
, WM8960_PLL4
, pll_div
.k
& 0xff);
861 snd_soc_write(codec
, WM8960_PLL1
, reg
);
864 snd_soc_update_bits(codec
, WM8960_POWER2
, 0x1, 0x1);
866 snd_soc_update_bits(codec
, WM8960_CLOCK1
, 0x1, 0x1);
871 static int wm8960_set_dai_clkdiv(struct snd_soc_dai
*codec_dai
,
874 struct snd_soc_codec
*codec
= codec_dai
->codec
;
878 case WM8960_SYSCLKDIV
:
879 reg
= snd_soc_read(codec
, WM8960_CLOCK1
) & 0x1f9;
880 snd_soc_write(codec
, WM8960_CLOCK1
, reg
| div
);
883 reg
= snd_soc_read(codec
, WM8960_CLOCK1
) & 0x1c7;
884 snd_soc_write(codec
, WM8960_CLOCK1
, reg
| div
);
886 case WM8960_OPCLKDIV
:
887 reg
= snd_soc_read(codec
, WM8960_PLL1
) & 0x03f;
888 snd_soc_write(codec
, WM8960_PLL1
, reg
| div
);
891 reg
= snd_soc_read(codec
, WM8960_CLOCK2
) & 0x03f;
892 snd_soc_write(codec
, WM8960_CLOCK2
, reg
| div
);
894 case WM8960_TOCLKSEL
:
895 reg
= snd_soc_read(codec
, WM8960_ADDCTL1
) & 0x1fd;
896 snd_soc_write(codec
, WM8960_ADDCTL1
, reg
| div
);
905 static int wm8960_set_bias_level(struct snd_soc_codec
*codec
,
906 enum snd_soc_bias_level level
)
908 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
910 return wm8960
->set_bias_level(codec
, level
);
913 #define WM8960_RATES SNDRV_PCM_RATE_8000_48000
915 #define WM8960_FORMATS \
916 (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
917 SNDRV_PCM_FMTBIT_S24_LE)
919 static const struct snd_soc_dai_ops wm8960_dai_ops
= {
920 .hw_params
= wm8960_hw_params
,
921 .digital_mute
= wm8960_mute
,
922 .set_fmt
= wm8960_set_dai_fmt
,
923 .set_clkdiv
= wm8960_set_dai_clkdiv
,
924 .set_pll
= wm8960_set_dai_pll
,
927 static struct snd_soc_dai_driver wm8960_dai
= {
928 .name
= "wm8960-hifi",
930 .stream_name
= "Playback",
933 .rates
= WM8960_RATES
,
934 .formats
= WM8960_FORMATS
,},
936 .stream_name
= "Capture",
939 .rates
= WM8960_RATES
,
940 .formats
= WM8960_FORMATS
,},
941 .ops
= &wm8960_dai_ops
,
942 .symmetric_rates
= 1,
945 static int wm8960_suspend(struct snd_soc_codec
*codec
)
947 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
949 wm8960
->set_bias_level(codec
, SND_SOC_BIAS_OFF
);
953 static int wm8960_resume(struct snd_soc_codec
*codec
)
955 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
957 wm8960
->set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
961 static int wm8960_probe(struct snd_soc_codec
*codec
)
963 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
964 struct wm8960_data
*pdata
= dev_get_platdata(codec
->dev
);
967 wm8960
->set_bias_level
= wm8960_set_bias_level_out3
;
970 dev_warn(codec
->dev
, "No platform data supplied\n");
973 wm8960
->set_bias_level
= wm8960_set_bias_level_capless
;
976 ret
= wm8960_reset(codec
);
978 dev_err(codec
->dev
, "Failed to issue reset\n");
982 wm8960
->set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
984 /* Latch the update bits */
985 snd_soc_update_bits(codec
, WM8960_LINVOL
, 0x100, 0x100);
986 snd_soc_update_bits(codec
, WM8960_RINVOL
, 0x100, 0x100);
987 snd_soc_update_bits(codec
, WM8960_LADC
, 0x100, 0x100);
988 snd_soc_update_bits(codec
, WM8960_RADC
, 0x100, 0x100);
989 snd_soc_update_bits(codec
, WM8960_LDAC
, 0x100, 0x100);
990 snd_soc_update_bits(codec
, WM8960_RDAC
, 0x100, 0x100);
991 snd_soc_update_bits(codec
, WM8960_LOUT1
, 0x100, 0x100);
992 snd_soc_update_bits(codec
, WM8960_ROUT1
, 0x100, 0x100);
993 snd_soc_update_bits(codec
, WM8960_LOUT2
, 0x100, 0x100);
994 snd_soc_update_bits(codec
, WM8960_ROUT2
, 0x100, 0x100);
996 snd_soc_add_codec_controls(codec
, wm8960_snd_controls
,
997 ARRAY_SIZE(wm8960_snd_controls
));
998 wm8960_add_widgets(codec
);
1003 /* power down chip */
1004 static int wm8960_remove(struct snd_soc_codec
*codec
)
1006 struct wm8960_priv
*wm8960
= snd_soc_codec_get_drvdata(codec
);
1008 wm8960
->set_bias_level(codec
, SND_SOC_BIAS_OFF
);
1012 static struct snd_soc_codec_driver soc_codec_dev_wm8960
= {
1013 .probe
= wm8960_probe
,
1014 .remove
= wm8960_remove
,
1015 .suspend
= wm8960_suspend
,
1016 .resume
= wm8960_resume
,
1017 .set_bias_level
= wm8960_set_bias_level
,
1020 static const struct regmap_config wm8960_regmap
= {
1023 .max_register
= WM8960_PLL4
,
1025 .reg_defaults
= wm8960_reg_defaults
,
1026 .num_reg_defaults
= ARRAY_SIZE(wm8960_reg_defaults
),
1027 .cache_type
= REGCACHE_RBTREE
,
1029 .volatile_reg
= wm8960_volatile
,
1032 static int wm8960_i2c_probe(struct i2c_client
*i2c
,
1033 const struct i2c_device_id
*id
)
1035 struct wm8960_data
*pdata
= dev_get_platdata(&i2c
->dev
);
1036 struct wm8960_priv
*wm8960
;
1039 wm8960
= devm_kzalloc(&i2c
->dev
, sizeof(struct wm8960_priv
),
1044 wm8960
->regmap
= devm_regmap_init_i2c(i2c
, &wm8960_regmap
);
1045 if (IS_ERR(wm8960
->regmap
))
1046 return PTR_ERR(wm8960
->regmap
);
1048 if (pdata
&& pdata
->shared_lrclk
) {
1049 ret
= regmap_update_bits(wm8960
->regmap
, WM8960_ADDCTL2
,
1052 dev_err(&i2c
->dev
, "Failed to enable LRCM: %d\n",
1058 i2c_set_clientdata(i2c
, wm8960
);
1060 ret
= snd_soc_register_codec(&i2c
->dev
,
1061 &soc_codec_dev_wm8960
, &wm8960_dai
, 1);
1066 static int wm8960_i2c_remove(struct i2c_client
*client
)
1068 snd_soc_unregister_codec(&client
->dev
);
1072 static const struct i2c_device_id wm8960_i2c_id
[] = {
1076 MODULE_DEVICE_TABLE(i2c
, wm8960_i2c_id
);
1078 static struct i2c_driver wm8960_i2c_driver
= {
1081 .owner
= THIS_MODULE
,
1083 .probe
= wm8960_i2c_probe
,
1084 .remove
= wm8960_i2c_remove
,
1085 .id_table
= wm8960_i2c_id
,
1088 module_i2c_driver(wm8960_i2c_driver
);
1090 MODULE_DESCRIPTION("ASoC WM8960 driver");
1091 MODULE_AUTHOR("Liam Girdwood");
1092 MODULE_LICENSE("GPL");