2 * wm8940.c -- WM8940 ALSA Soc Audio driver
4 * Author: Jonathan Cameron <jic23@cam.ac.uk>
7 * Copyright 2006 Wolfson Microelectronics PLC.
8 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
14 * Not currently handled:
15 * Notch filter control
16 * AUXMode (inverting vs mixer)
17 * No means to obtain current gain if alc enabled.
19 * Fast VMID discharge for power down
21 * DLR and ALR Swaps not enabled
22 * Digital Sidetone not supported
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/delay.h>
30 #include <linux/i2c.h>
31 #include <linux/platform_device.h>
32 #include <linux/spi/spi.h>
33 #include <linux/slab.h>
34 #include <sound/core.h>
35 #include <sound/pcm.h>
36 #include <sound/pcm_params.h>
37 #include <sound/soc.h>
38 #include <sound/soc-dapm.h>
39 #include <sound/initval.h>
40 #include <sound/tlv.h>
46 u16 reg_cache
[WM8940_CACHEREGNUM
];
47 enum snd_soc_control_type control_type
;
51 static u16 wm8940_reg_defaults
[] = {
52 0x8940, /* Soft Reset */
56 0x0010, /* Interface Control */
57 0x0000, /* Companding Control */
58 0x0140, /* Clock Control */
59 0x0000, /* Additional Controls */
60 0x0000, /* GPIO Control */
61 0x0002, /* Auto Increment Control */
62 0x0000, /* DAC Control */
63 0x00FF, /* DAC Volume */
66 0x0100, /* ADC Control */
67 0x00FF, /* ADC Volume */
68 0x0000, /* Notch Filter 1 Control 1 */
69 0x0000, /* Notch Filter 1 Control 2 */
70 0x0000, /* Notch Filter 2 Control 1 */
71 0x0000, /* Notch Filter 2 Control 2 */
72 0x0000, /* Notch Filter 3 Control 1 */
73 0x0000, /* Notch Filter 3 Control 2 */
74 0x0000, /* Notch Filter 4 Control 1 */
75 0x0000, /* Notch Filter 4 Control 2 */
76 0x0032, /* DAC Limit Control 1 */
77 0x0000, /* DAC Limit Control 2 */
84 0x0038, /* ALC Control 1 */
85 0x000B, /* ALC Control 2 */
86 0x0032, /* ALC Control 3 */
87 0x0000, /* Noise Gate */
94 0x0030, /* ALC Control 4 */
96 0x0002, /* Input Control */
97 0x0050, /* PGA Gain */
99 0x0002, /* ADC Boost Control */
101 0x0002, /* Output Control */
102 0x0000, /* Speaker Mixer Control */
106 0x0079, /* Speaker Volume */
108 0x0000, /* Mono Mixer Control */
111 static const char *wm8940_companding
[] = { "Off", "NC", "u-law", "A-law" };
112 static const struct soc_enum wm8940_adc_companding_enum
113 = SOC_ENUM_SINGLE(WM8940_COMPANDINGCTL
, 1, 4, wm8940_companding
);
114 static const struct soc_enum wm8940_dac_companding_enum
115 = SOC_ENUM_SINGLE(WM8940_COMPANDINGCTL
, 3, 4, wm8940_companding
);
117 static const char *wm8940_alc_mode_text
[] = {"ALC", "Limiter"};
118 static const struct soc_enum wm8940_alc_mode_enum
119 = SOC_ENUM_SINGLE(WM8940_ALC3
, 8, 2, wm8940_alc_mode_text
);
121 static const char *wm8940_mic_bias_level_text
[] = {"0.9", "0.65"};
122 static const struct soc_enum wm8940_mic_bias_level_enum
123 = SOC_ENUM_SINGLE(WM8940_INPUTCTL
, 8, 2, wm8940_mic_bias_level_text
);
125 static const char *wm8940_filter_mode_text
[] = {"Audio", "Application"};
126 static const struct soc_enum wm8940_filter_mode_enum
127 = SOC_ENUM_SINGLE(WM8940_ADC
, 7, 2, wm8940_filter_mode_text
);
129 static DECLARE_TLV_DB_SCALE(wm8940_spk_vol_tlv
, -5700, 100, 1);
130 static DECLARE_TLV_DB_SCALE(wm8940_att_tlv
, -1000, 1000, 0);
131 static DECLARE_TLV_DB_SCALE(wm8940_pga_vol_tlv
, -1200, 75, 0);
132 static DECLARE_TLV_DB_SCALE(wm8940_alc_min_tlv
, -1200, 600, 0);
133 static DECLARE_TLV_DB_SCALE(wm8940_alc_max_tlv
, 675, 600, 0);
134 static DECLARE_TLV_DB_SCALE(wm8940_alc_tar_tlv
, -2250, 50, 0);
135 static DECLARE_TLV_DB_SCALE(wm8940_lim_boost_tlv
, 0, 100, 0);
136 static DECLARE_TLV_DB_SCALE(wm8940_lim_thresh_tlv
, -600, 100, 0);
137 static DECLARE_TLV_DB_SCALE(wm8940_adc_tlv
, -12750, 50, 1);
138 static DECLARE_TLV_DB_SCALE(wm8940_capture_boost_vol_tlv
, 0, 2000, 0);
140 static const struct snd_kcontrol_new wm8940_snd_controls
[] = {
141 SOC_SINGLE("Digital Loopback Switch", WM8940_COMPANDINGCTL
,
143 SOC_ENUM("DAC Companding", wm8940_dac_companding_enum
),
144 SOC_ENUM("ADC Companding", wm8940_adc_companding_enum
),
146 SOC_ENUM("ALC Mode", wm8940_alc_mode_enum
),
147 SOC_SINGLE("ALC Switch", WM8940_ALC1
, 8, 1, 0),
148 SOC_SINGLE_TLV("ALC Capture Max Gain", WM8940_ALC1
,
149 3, 7, 1, wm8940_alc_max_tlv
),
150 SOC_SINGLE_TLV("ALC Capture Min Gain", WM8940_ALC1
,
151 0, 7, 0, wm8940_alc_min_tlv
),
152 SOC_SINGLE_TLV("ALC Capture Target", WM8940_ALC2
,
153 0, 14, 0, wm8940_alc_tar_tlv
),
154 SOC_SINGLE("ALC Capture Hold", WM8940_ALC2
, 4, 10, 0),
155 SOC_SINGLE("ALC Capture Decay", WM8940_ALC3
, 4, 10, 0),
156 SOC_SINGLE("ALC Capture Attach", WM8940_ALC3
, 0, 10, 0),
157 SOC_SINGLE("ALC ZC Switch", WM8940_ALC4
, 1, 1, 0),
158 SOC_SINGLE("ALC Capture Noise Gate Switch", WM8940_NOISEGATE
,
160 SOC_SINGLE("ALC Capture Noise Gate Threshold", WM8940_NOISEGATE
,
163 SOC_SINGLE("DAC Playback Limiter Switch", WM8940_DACLIM1
, 8, 1, 0),
164 SOC_SINGLE("DAC Playback Limiter Attack", WM8940_DACLIM1
, 0, 9, 0),
165 SOC_SINGLE("DAC Playback Limiter Decay", WM8940_DACLIM1
, 4, 11, 0),
166 SOC_SINGLE_TLV("DAC Playback Limiter Threshold", WM8940_DACLIM2
,
167 4, 9, 1, wm8940_lim_thresh_tlv
),
168 SOC_SINGLE_TLV("DAC Playback Limiter Boost", WM8940_DACLIM2
,
169 0, 12, 0, wm8940_lim_boost_tlv
),
171 SOC_SINGLE("Capture PGA ZC Switch", WM8940_PGAGAIN
, 7, 1, 0),
172 SOC_SINGLE_TLV("Capture PGA Volume", WM8940_PGAGAIN
,
173 0, 63, 0, wm8940_pga_vol_tlv
),
174 SOC_SINGLE_TLV("Digital Playback Volume", WM8940_DACVOL
,
175 0, 255, 0, wm8940_adc_tlv
),
176 SOC_SINGLE_TLV("Digital Capture Volume", WM8940_ADCVOL
,
177 0, 255, 0, wm8940_adc_tlv
),
178 SOC_ENUM("Mic Bias Level", wm8940_mic_bias_level_enum
),
179 SOC_SINGLE_TLV("Capture Boost Volue", WM8940_ADCBOOST
,
180 8, 1, 0, wm8940_capture_boost_vol_tlv
),
181 SOC_SINGLE_TLV("Speaker Playback Volume", WM8940_SPKVOL
,
182 0, 63, 0, wm8940_spk_vol_tlv
),
183 SOC_SINGLE("Speaker Playback Switch", WM8940_SPKVOL
, 6, 1, 1),
185 SOC_SINGLE_TLV("Speaker Mixer Line Bypass Volume", WM8940_SPKVOL
,
186 8, 1, 1, wm8940_att_tlv
),
187 SOC_SINGLE("Speaker Playback ZC Switch", WM8940_SPKVOL
, 7, 1, 0),
189 SOC_SINGLE("Mono Out Switch", WM8940_MONOMIX
, 6, 1, 1),
190 SOC_SINGLE_TLV("Mono Mixer Line Bypass Volume", WM8940_MONOMIX
,
191 7, 1, 1, wm8940_att_tlv
),
193 SOC_SINGLE("High Pass Filter Switch", WM8940_ADC
, 8, 1, 0),
194 SOC_ENUM("High Pass Filter Mode", wm8940_filter_mode_enum
),
195 SOC_SINGLE("High Pass Filter Cut Off", WM8940_ADC
, 4, 7, 0),
196 SOC_SINGLE("ADC Inversion Switch", WM8940_ADC
, 0, 1, 0),
197 SOC_SINGLE("DAC Inversion Switch", WM8940_DAC
, 0, 1, 0),
198 SOC_SINGLE("DAC Auto Mute Switch", WM8940_DAC
, 2, 1, 0),
199 SOC_SINGLE("ZC Timeout Clock Switch", WM8940_ADDCNTRL
, 0, 1, 0),
202 static const struct snd_kcontrol_new wm8940_speaker_mixer_controls
[] = {
203 SOC_DAPM_SINGLE("Line Bypass Switch", WM8940_SPKMIX
, 1, 1, 0),
204 SOC_DAPM_SINGLE("Aux Playback Switch", WM8940_SPKMIX
, 5, 1, 0),
205 SOC_DAPM_SINGLE("PCM Playback Switch", WM8940_SPKMIX
, 0, 1, 0),
208 static const struct snd_kcontrol_new wm8940_mono_mixer_controls
[] = {
209 SOC_DAPM_SINGLE("Line Bypass Switch", WM8940_MONOMIX
, 1, 1, 0),
210 SOC_DAPM_SINGLE("Aux Playback Switch", WM8940_MONOMIX
, 2, 1, 0),
211 SOC_DAPM_SINGLE("PCM Playback Switch", WM8940_MONOMIX
, 0, 1, 0),
214 static DECLARE_TLV_DB_SCALE(wm8940_boost_vol_tlv
, -1500, 300, 1);
215 static const struct snd_kcontrol_new wm8940_input_boost_controls
[] = {
216 SOC_DAPM_SINGLE("Mic PGA Switch", WM8940_PGAGAIN
, 6, 1, 1),
217 SOC_DAPM_SINGLE_TLV("Aux Volume", WM8940_ADCBOOST
,
218 0, 7, 0, wm8940_boost_vol_tlv
),
219 SOC_DAPM_SINGLE_TLV("Mic Volume", WM8940_ADCBOOST
,
220 4, 7, 0, wm8940_boost_vol_tlv
),
223 static const struct snd_kcontrol_new wm8940_micpga_controls
[] = {
224 SOC_DAPM_SINGLE("AUX Switch", WM8940_INPUTCTL
, 2, 1, 0),
225 SOC_DAPM_SINGLE("MICP Switch", WM8940_INPUTCTL
, 0, 1, 0),
226 SOC_DAPM_SINGLE("MICN Switch", WM8940_INPUTCTL
, 1, 1, 0),
229 static const struct snd_soc_dapm_widget wm8940_dapm_widgets
[] = {
230 SND_SOC_DAPM_MIXER("Speaker Mixer", WM8940_POWER3
, 2, 0,
231 &wm8940_speaker_mixer_controls
[0],
232 ARRAY_SIZE(wm8940_speaker_mixer_controls
)),
233 SND_SOC_DAPM_MIXER("Mono Mixer", WM8940_POWER3
, 3, 0,
234 &wm8940_mono_mixer_controls
[0],
235 ARRAY_SIZE(wm8940_mono_mixer_controls
)),
236 SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8940_POWER3
, 0, 0),
238 SND_SOC_DAPM_PGA("SpkN Out", WM8940_POWER3
, 5, 0, NULL
, 0),
239 SND_SOC_DAPM_PGA("SpkP Out", WM8940_POWER3
, 6, 0, NULL
, 0),
240 SND_SOC_DAPM_PGA("Mono Out", WM8940_POWER3
, 7, 0, NULL
, 0),
241 SND_SOC_DAPM_OUTPUT("MONOOUT"),
242 SND_SOC_DAPM_OUTPUT("SPKOUTP"),
243 SND_SOC_DAPM_OUTPUT("SPKOUTN"),
245 SND_SOC_DAPM_PGA("Aux Input", WM8940_POWER1
, 6, 0, NULL
, 0),
246 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8940_POWER2
, 0, 0),
247 SND_SOC_DAPM_MIXER("Mic PGA", WM8940_POWER2
, 2, 0,
248 &wm8940_micpga_controls
[0],
249 ARRAY_SIZE(wm8940_micpga_controls
)),
250 SND_SOC_DAPM_MIXER("Boost Mixer", WM8940_POWER2
, 4, 0,
251 &wm8940_input_boost_controls
[0],
252 ARRAY_SIZE(wm8940_input_boost_controls
)),
253 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8940_POWER1
, 4, 0),
255 SND_SOC_DAPM_INPUT("MICN"),
256 SND_SOC_DAPM_INPUT("MICP"),
257 SND_SOC_DAPM_INPUT("AUX"),
260 static const struct snd_soc_dapm_route audio_map
[] = {
261 /* Mono output mixer */
262 {"Mono Mixer", "PCM Playback Switch", "DAC"},
263 {"Mono Mixer", "Aux Playback Switch", "Aux Input"},
264 {"Mono Mixer", "Line Bypass Switch", "Boost Mixer"},
266 /* Speaker output mixer */
267 {"Speaker Mixer", "PCM Playback Switch", "DAC"},
268 {"Speaker Mixer", "Aux Playback Switch", "Aux Input"},
269 {"Speaker Mixer", "Line Bypass Switch", "Boost Mixer"},
272 {"Mono Out", NULL
, "Mono Mixer"},
273 {"MONOOUT", NULL
, "Mono Out"},
274 {"SpkN Out", NULL
, "Speaker Mixer"},
275 {"SpkP Out", NULL
, "Speaker Mixer"},
276 {"SPKOUTN", NULL
, "SpkN Out"},
277 {"SPKOUTP", NULL
, "SpkP Out"},
280 {"Mic PGA", "MICN Switch", "MICN"},
281 {"Mic PGA", "MICP Switch", "MICP"},
282 {"Mic PGA", "AUX Switch", "AUX"},
285 {"Boost Mixer", "Mic PGA Switch", "Mic PGA"},
286 {"Boost Mixer", "Mic Volume", "MICP"},
287 {"Boost Mixer", "Aux Volume", "Aux Input"},
289 {"ADC", NULL
, "Boost Mixer"},
292 static int wm8940_add_widgets(struct snd_soc_codec
*codec
)
296 ret
= snd_soc_dapm_new_controls(codec
, wm8940_dapm_widgets
,
297 ARRAY_SIZE(wm8940_dapm_widgets
));
300 ret
= snd_soc_dapm_add_routes(codec
, audio_map
, ARRAY_SIZE(audio_map
));
308 #define wm8940_reset(c) snd_soc_write(c, WM8940_SOFTRESET, 0);
310 static int wm8940_set_dai_fmt(struct snd_soc_dai
*codec_dai
,
313 struct snd_soc_codec
*codec
= codec_dai
->codec
;
314 u16 iface
= snd_soc_read(codec
, WM8940_IFACE
) & 0xFE67;
315 u16 clk
= snd_soc_read(codec
, WM8940_CLOCK
) & 0x1fe;
317 switch (fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
318 case SND_SOC_DAIFMT_CBM_CFM
:
321 case SND_SOC_DAIFMT_CBS_CFS
:
326 snd_soc_write(codec
, WM8940_CLOCK
, clk
);
328 switch (fmt
& SND_SOC_DAIFMT_FORMAT_MASK
) {
329 case SND_SOC_DAIFMT_I2S
:
332 case SND_SOC_DAIFMT_LEFT_J
:
335 case SND_SOC_DAIFMT_RIGHT_J
:
337 case SND_SOC_DAIFMT_DSP_A
:
340 case SND_SOC_DAIFMT_DSP_B
:
341 iface
|= (3 << 3) | (1 << 7);
345 switch (fmt
& SND_SOC_DAIFMT_INV_MASK
) {
346 case SND_SOC_DAIFMT_NB_NF
:
348 case SND_SOC_DAIFMT_NB_IF
:
351 case SND_SOC_DAIFMT_IB_NF
:
354 case SND_SOC_DAIFMT_IB_IF
:
355 iface
|= (1 << 8) | (1 << 7);
359 snd_soc_write(codec
, WM8940_IFACE
, iface
);
364 static int wm8940_i2s_hw_params(struct snd_pcm_substream
*substream
,
365 struct snd_pcm_hw_params
*params
,
366 struct snd_soc_dai
*dai
)
368 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
369 struct snd_soc_codec
*codec
= rtd
->codec
;
370 u16 iface
= snd_soc_read(codec
, WM8940_IFACE
) & 0xFD9F;
371 u16 addcntrl
= snd_soc_read(codec
, WM8940_ADDCNTRL
) & 0xFFF1;
372 u16 companding
= snd_soc_read(codec
,
373 WM8940_COMPANDINGCTL
) & 0xFFDF;
377 if (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
378 && params_channels(params
) == 2)
381 switch (params_rate(params
)) {
383 addcntrl
|= (0x5 << 1);
386 addcntrl
|= (0x4 << 1);
389 addcntrl
|= (0x3 << 1);
392 addcntrl
|= (0x2 << 1);
395 addcntrl
|= (0x1 << 1);
401 ret
= snd_soc_write(codec
, WM8940_ADDCNTRL
, addcntrl
);
405 switch (params_format(params
)) {
406 case SNDRV_PCM_FORMAT_S8
:
407 companding
= companding
| (1 << 5);
409 case SNDRV_PCM_FORMAT_S16_LE
:
411 case SNDRV_PCM_FORMAT_S20_3LE
:
414 case SNDRV_PCM_FORMAT_S24_LE
:
417 case SNDRV_PCM_FORMAT_S32_LE
:
421 ret
= snd_soc_write(codec
, WM8940_COMPANDINGCTL
, companding
);
424 ret
= snd_soc_write(codec
, WM8940_IFACE
, iface
);
430 static int wm8940_mute(struct snd_soc_dai
*dai
, int mute
)
432 struct snd_soc_codec
*codec
= dai
->codec
;
433 u16 mute_reg
= snd_soc_read(codec
, WM8940_DAC
) & 0xffbf;
438 return snd_soc_write(codec
, WM8940_DAC
, mute_reg
);
441 static int wm8940_set_bias_level(struct snd_soc_codec
*codec
,
442 enum snd_soc_bias_level level
)
445 u16 pwr_reg
= snd_soc_read(codec
, WM8940_POWER1
) & 0x1F0;
449 case SND_SOC_BIAS_ON
:
450 /* ensure bufioen and biasen */
451 pwr_reg
|= (1 << 2) | (1 << 3);
452 /* Enable thermal shutdown */
453 val
= snd_soc_read(codec
, WM8940_OUTPUTCTL
);
454 ret
= snd_soc_write(codec
, WM8940_OUTPUTCTL
, val
| 0x2);
457 /* set vmid to 75k */
458 ret
= snd_soc_write(codec
, WM8940_POWER1
, pwr_reg
| 0x1);
460 case SND_SOC_BIAS_PREPARE
:
461 /* ensure bufioen and biasen */
462 pwr_reg
|= (1 << 2) | (1 << 3);
463 ret
= snd_soc_write(codec
, WM8940_POWER1
, pwr_reg
| 0x1);
465 case SND_SOC_BIAS_STANDBY
:
466 /* ensure bufioen and biasen */
467 pwr_reg
|= (1 << 2) | (1 << 3);
468 /* set vmid to 300k for standby */
469 ret
= snd_soc_write(codec
, WM8940_POWER1
, pwr_reg
| 0x2);
471 case SND_SOC_BIAS_OFF
:
472 ret
= snd_soc_write(codec
, WM8940_POWER1
, pwr_reg
);
480 unsigned int pre_scale
:2;
485 static struct pll_ pll_div
;
487 /* The size in bits of the pll divide multiplied by 10
488 * to allow rounding later */
489 #define FIXED_PLL_SIZE ((1 << 24) * 10)
490 static void pll_factors(unsigned int target
, unsigned int source
)
492 unsigned long long Kpart
;
493 unsigned int K
, Ndiv
, Nmod
;
494 /* The left shift ist to avoid accuracy loss when right shifting */
495 Ndiv
= target
/ source
;
500 pll_div
.pre_scale
= 0;
501 Ndiv
= target
/ source
;
502 } else if (Ndiv
< 3) {
505 pll_div
.pre_scale
= 3;
506 Ndiv
= target
/ source
;
507 } else if (Ndiv
< 6) {
510 pll_div
.pre_scale
= 2;
511 Ndiv
= target
/ source
;
513 pll_div
.pre_scale
= 1;
515 if ((Ndiv
< 6) || (Ndiv
> 12))
517 "WM8940 N value %d outwith recommended range!d\n",
521 Nmod
= target
% source
;
522 Kpart
= FIXED_PLL_SIZE
* (long long)Nmod
;
524 do_div(Kpart
, source
);
526 K
= Kpart
& 0xFFFFFFFF;
528 /* Check if we need to round */
532 /* Move down to proper range now rounding is done */
538 /* Untested at the moment */
539 static int wm8940_set_dai_pll(struct snd_soc_dai
*codec_dai
, int pll_id
,
540 int source
, unsigned int freq_in
, unsigned int freq_out
)
542 struct snd_soc_codec
*codec
= codec_dai
->codec
;
546 reg
= snd_soc_read(codec
, WM8940_POWER1
);
547 snd_soc_write(codec
, WM8940_POWER1
, reg
& 0x1df);
549 if (freq_in
== 0 || freq_out
== 0) {
550 /* Clock CODEC directly from MCLK */
551 reg
= snd_soc_read(codec
, WM8940_CLOCK
);
552 snd_soc_write(codec
, WM8940_CLOCK
, reg
& 0x0ff);
554 snd_soc_write(codec
, WM8940_PLLN
, (1 << 7));
558 /* Pll is followed by a frequency divide by 4 */
559 pll_factors(freq_out
*4, freq_in
);
561 snd_soc_write(codec
, WM8940_PLLN
,
562 (pll_div
.pre_scale
<< 4) | pll_div
.n
| (1 << 6));
563 else /* No factional component */
564 snd_soc_write(codec
, WM8940_PLLN
,
565 (pll_div
.pre_scale
<< 4) | pll_div
.n
);
566 snd_soc_write(codec
, WM8940_PLLK1
, pll_div
.k
>> 18);
567 snd_soc_write(codec
, WM8940_PLLK2
, (pll_div
.k
>> 9) & 0x1ff);
568 snd_soc_write(codec
, WM8940_PLLK3
, pll_div
.k
& 0x1ff);
570 reg
= snd_soc_read(codec
, WM8940_POWER1
);
571 snd_soc_write(codec
, WM8940_POWER1
, reg
| 0x020);
573 /* Run CODEC from PLL instead of MCLK */
574 reg
= snd_soc_read(codec
, WM8940_CLOCK
);
575 snd_soc_write(codec
, WM8940_CLOCK
, reg
| 0x100);
580 static int wm8940_set_dai_sysclk(struct snd_soc_dai
*codec_dai
,
581 int clk_id
, unsigned int freq
, int dir
)
583 struct snd_soc_codec
*codec
= codec_dai
->codec
;
584 struct wm8940_priv
*wm8940
= snd_soc_codec_get_drvdata(codec
);
592 wm8940
->sysclk
= freq
;
598 static int wm8940_set_dai_clkdiv(struct snd_soc_dai
*codec_dai
,
601 struct snd_soc_codec
*codec
= codec_dai
->codec
;
607 reg
= snd_soc_read(codec
, WM8940_CLOCK
) & 0xFFEF3;
608 ret
= snd_soc_write(codec
, WM8940_CLOCK
, reg
| (div
<< 2));
611 reg
= snd_soc_read(codec
, WM8940_CLOCK
) & 0xFF1F;
612 ret
= snd_soc_write(codec
, WM8940_CLOCK
, reg
| (div
<< 5));
614 case WM8940_OPCLKDIV
:
615 reg
= snd_soc_read(codec
, WM8940_ADDCNTRL
) & 0xFFCF;
616 ret
= snd_soc_write(codec
, WM8940_ADDCNTRL
, reg
| (div
<< 4));
622 #define WM8940_RATES SNDRV_PCM_RATE_8000_48000
624 #define WM8940_FORMATS (SNDRV_PCM_FMTBIT_S8 | \
625 SNDRV_PCM_FMTBIT_S16_LE | \
626 SNDRV_PCM_FMTBIT_S20_3LE | \
627 SNDRV_PCM_FMTBIT_S24_LE | \
628 SNDRV_PCM_FMTBIT_S32_LE)
630 static struct snd_soc_dai_ops wm8940_dai_ops
= {
631 .hw_params
= wm8940_i2s_hw_params
,
632 .set_sysclk
= wm8940_set_dai_sysclk
,
633 .digital_mute
= wm8940_mute
,
634 .set_fmt
= wm8940_set_dai_fmt
,
635 .set_clkdiv
= wm8940_set_dai_clkdiv
,
636 .set_pll
= wm8940_set_dai_pll
,
639 static struct snd_soc_dai_driver wm8940_dai
= {
640 .name
= "wm8940-hifi",
642 .stream_name
= "Playback",
645 .rates
= WM8940_RATES
,
646 .formats
= WM8940_FORMATS
,
649 .stream_name
= "Capture",
652 .rates
= WM8940_RATES
,
653 .formats
= WM8940_FORMATS
,
655 .ops
= &wm8940_dai_ops
,
656 .symmetric_rates
= 1,
659 static int wm8940_suspend(struct snd_soc_codec
*codec
, pm_message_t state
)
661 return wm8940_set_bias_level(codec
, SND_SOC_BIAS_OFF
);
664 static int wm8940_resume(struct snd_soc_codec
*codec
)
669 u16
*cache
= codec
->reg_cache
;
671 /* Sync reg_cache with the hardware
672 * Could use auto incremented writes to speed this up
674 for (i
= 0; i
< ARRAY_SIZE(wm8940_reg_defaults
); i
++) {
676 data
[1] = (cache
[i
] & 0xFF00) >> 8;
677 data
[2] = cache
[i
] & 0x00FF;
678 ret
= codec
->hw_write(codec
->control_data
, data
, 3);
686 ret
= wm8940_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
694 static int wm8940_probe(struct snd_soc_codec
*codec
)
696 struct wm8940_priv
*wm8940
= snd_soc_codec_get_drvdata(codec
);
697 struct wm8940_setup_data
*pdata
= codec
->dev
->platform_data
;
701 codec
->control_data
= wm8940
->control_data
;
702 ret
= snd_soc_codec_set_cache_io(codec
, 8, 16, wm8940
->control_type
);
704 dev_err(codec
->dev
, "Failed to set cache I/O: %d\n", ret
);
708 ret
= wm8940_reset(codec
);
710 dev_err(codec
->dev
, "Failed to issue reset\n");
714 wm8940_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
716 ret
= snd_soc_write(codec
, WM8940_POWER1
, 0x180);
721 dev_warn(codec
->dev
, "No platform data supplied\n");
723 reg
= snd_soc_read(codec
, WM8940_OUTPUTCTL
);
724 ret
= snd_soc_write(codec
, WM8940_OUTPUTCTL
, reg
| pdata
->vroi
);
729 ret
= snd_soc_add_controls(codec
, wm8940_snd_controls
,
730 ARRAY_SIZE(wm8940_snd_controls
));
733 ret
= wm8940_add_widgets(codec
);
741 static int wm8940_remove(struct snd_soc_codec
*codec
)
743 wm8940_set_bias_level(codec
, SND_SOC_BIAS_OFF
);
747 static struct snd_soc_codec_driver soc_codec_dev_wm8940
= {
748 .probe
= wm8940_probe
,
749 .remove
= wm8940_remove
,
750 .suspend
= wm8940_suspend
,
751 .resume
= wm8940_resume
,
752 .set_bias_level
= wm8940_set_bias_level
,
753 .reg_cache_size
= ARRAY_SIZE(wm8940_reg_defaults
),
754 .reg_word_size
= sizeof(u16
),
755 .reg_cache_default
= wm8940_reg_defaults
,
758 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
759 static __devinit
int wm8940_i2c_probe(struct i2c_client
*i2c
,
760 const struct i2c_device_id
*id
)
762 struct wm8940_priv
*wm8940
;
765 wm8940
= kzalloc(sizeof(struct wm8940_priv
), GFP_KERNEL
);
769 i2c_set_clientdata(i2c
, wm8940
);
770 wm8940
->control_data
= i2c
;
772 ret
= snd_soc_register_codec(&i2c
->dev
,
773 &soc_codec_dev_wm8940
, &wm8940_dai
, 1);
779 static __devexit
int wm8940_i2c_remove(struct i2c_client
*client
)
781 snd_soc_unregister_codec(&client
->dev
);
782 kfree(i2c_get_clientdata(client
));
786 static const struct i2c_device_id wm8940_i2c_id
[] = {
790 MODULE_DEVICE_TABLE(i2c
, wm8940_i2c_id
);
792 static struct i2c_driver wm8940_i2c_driver
= {
794 .name
= "wm8940-codec",
795 .owner
= THIS_MODULE
,
797 .probe
= wm8940_i2c_probe
,
798 .remove
= __devexit_p(wm8940_i2c_remove
),
799 .id_table
= wm8940_i2c_id
,
803 static int __init
wm8940_modinit(void)
806 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
807 ret
= i2c_add_driver(&wm8940_i2c_driver
);
809 printk(KERN_ERR
"Failed to register wm8940 I2C driver: %d\n",
815 module_init(wm8940_modinit
);
817 static void __exit
wm8940_exit(void)
819 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
820 i2c_del_driver(&wm8940_i2c_driver
);
823 module_exit(wm8940_exit
);
825 MODULE_DESCRIPTION("ASoC WM8940 driver");
826 MODULE_AUTHOR("Jonathan Cameron");
827 MODULE_LICENSE("GPL");