2 * wm8753.c -- WM8753 ALSA Soc Audio driver
4 * Copyright 2003 Wolfson Microelectronics PLC.
5 * Author: Liam Girdwood
6 * liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
14 * The WM8753 is a low power, high quality stereo codec with integrated PCM
15 * codec designed for portable digital telephony applications.
19 * This driver support 2 DAI PCM's. This makes the default PCM available for
20 * HiFi audio (e.g. MP3, ogg) playback/capture and the other PCM available for
23 * Please note that the voice PCM can be connected directly to a Bluetooth
24 * codec or GSM modem and thus cannot be read or written to, although it is
25 * available to be configured with snd_hw_params(), etc and kcontrols in the
28 * Fast DAI switching:-
30 * The driver can now fast switch between the DAI configurations via a
31 * an alsa kcontrol. This allows the PCM to remain open.
35 #include <linux/module.h>
36 #include <linux/moduleparam.h>
37 #include <linux/version.h>
38 #include <linux/kernel.h>
39 #include <linux/init.h>
40 #include <linux/delay.h>
42 #include <linux/i2c.h>
43 #include <linux/platform_device.h>
44 #include <sound/core.h>
45 #include <sound/pcm.h>
46 #include <sound/pcm_params.h>
47 #include <sound/soc.h>
48 #include <sound/soc-dapm.h>
49 #include <sound/initval.h>
50 #include <sound/tlv.h>
51 #include <asm/div64.h>
55 #define AUDIO_NAME "wm8753"
56 #define WM8753_VERSION "0.16"
62 #define WM8753_DEBUG 0
65 #define dbg(format, arg...) \
66 printk(KERN_DEBUG AUDIO_NAME ": " format "\n" , ## arg)
68 #define dbg(format, arg...) do {} while (0)
70 #define err(format, arg...) \
71 printk(KERN_ERR AUDIO_NAME ": " format "\n" , ## arg)
72 #define info(format, arg...) \
73 printk(KERN_INFO AUDIO_NAME ": " format "\n" , ## arg)
74 #define warn(format, arg...) \
75 printk(KERN_WARNING AUDIO_NAME ": " format "\n" , ## arg)
77 static int caps_charge = 2000;
78 module_param(caps_charge, int, 0);
79 MODULE_PARM_DESC(caps_charge, "WM8753 cap charge time (msecs)");
81 static void wm8753_set_dai_mode(struct snd_soc_codec *codec,
84 /* codec private data */
91 * wm8753 register cache
92 * We can't read the WM8753 register space when we
93 * are using 2 wire for device control, so we cache them instead.
95 static const u16 wm8753_reg[] = {
96 0x0008, 0x0000, 0x000a, 0x000a,
97 0x0033, 0x0000, 0x0007, 0x00ff,
98 0x00ff, 0x000f, 0x000f, 0x007b,
99 0x0000, 0x0032, 0x0000, 0x00c3,
100 0x00c3, 0x00c0, 0x0000, 0x0000,
101 0x0000, 0x0000, 0x0000, 0x0000,
102 0x0000, 0x0000, 0x0000, 0x0000,
103 0x0000, 0x0000, 0x0000, 0x0055,
104 0x0005, 0x0050, 0x0055, 0x0050,
105 0x0055, 0x0050, 0x0055, 0x0079,
106 0x0079, 0x0079, 0x0079, 0x0079,
107 0x0000, 0x0000, 0x0000, 0x0000,
108 0x0097, 0x0097, 0x0000, 0x0004,
109 0x0000, 0x0083, 0x0024, 0x01ba,
110 0x0000, 0x0083, 0x0024, 0x01ba,
115 * read wm8753 register cache
117 static inline unsigned int wm8753_read_reg_cache(struct snd_soc_codec *codec,
120 u16 *cache = codec->reg_cache;
121 if (reg < 1 || reg > (ARRAY_SIZE(wm8753_reg) + 1))
123 return cache[reg - 1];
127 * write wm8753 register cache
129 static inline void wm8753_write_reg_cache(struct snd_soc_codec *codec,
130 unsigned int reg, unsigned int value)
132 u16 *cache = codec->reg_cache;
133 if (reg < 1 || reg > 0x3f)
135 cache[reg - 1] = value;
139 * write to the WM8753 register space
141 static int wm8753_write(struct snd_soc_codec *codec, unsigned int reg,
147 * D15..D9 WM8753 register offset
148 * D8...D0 register data
150 data[0] = (reg << 1) | ((value >> 8) & 0x0001);
151 data[1] = value & 0x00ff;
153 wm8753_write_reg_cache(codec, reg, value);
154 if (codec->hw_write(codec->control_data, data, 2) == 2)
160 #define wm8753_reset(c) wm8753_write(c, WM8753_RESET, 0)
165 static const char *wm8753_base[] = {"Linear Control", "Adaptive Boost"};
166 static const char *wm8753_base_filter[] =
167 {"130Hz @ 48kHz", "200Hz @ 48kHz", "100Hz @ 16kHz", "400Hz @ 48kHz",
168 "100Hz @ 8kHz", "200Hz @ 8kHz"};
169 static const char *wm8753_treble[] = {"8kHz", "4kHz"};
170 static const char *wm8753_alc_func[] = {"Off", "Right", "Left", "Stereo"};
171 static const char *wm8753_ng_type[] = {"Constant PGA Gain", "Mute ADC Output"};
172 static const char *wm8753_3d_func[] = {"Capture", "Playback"};
173 static const char *wm8753_3d_uc[] = {"2.2kHz", "1.5kHz"};
174 static const char *wm8753_3d_lc[] = {"200Hz", "500Hz"};
175 static const char *wm8753_deemp[] = {"None", "32kHz", "44.1kHz", "48kHz"};
176 static const char *wm8753_mono_mix[] = {"Stereo", "Left", "Right", "Mono"};
177 static const char *wm8753_dac_phase[] = {"Non Inverted", "Inverted"};
178 static const char *wm8753_line_mix[] = {"Line 1 + 2", "Line 1 - 2",
180 static const char *wm8753_mono_mux[] = {"Line Mix", "Rx Mix"};
181 static const char *wm8753_right_mux[] = {"Line 2", "Rx Mix"};
182 static const char *wm8753_left_mux[] = {"Line 1", "Rx Mix"};
183 static const char *wm8753_rxmsel[] = {"RXP - RXN", "RXP + RXN", "RXP", "RXN"};
184 static const char *wm8753_sidetone_mux[] = {"Left PGA", "Mic 1", "Mic 2",
186 static const char *wm8753_mono2_src[] = {"Inverted Mono 1", "Left", "Right",
188 static const char *wm8753_out3[] = {"VREF", "ROUT2", "Left + Right"};
189 static const char *wm8753_out4[] = {"VREF", "Capture ST", "LOUT2"};
190 static const char *wm8753_radcsel[] = {"PGA", "Line or RXP-RXN", "Sidetone"};
191 static const char *wm8753_ladcsel[] = {"PGA", "Line or RXP-RXN", "Line"};
192 static const char *wm8753_mono_adc[] = {"Stereo", "Analogue Mix Left",
193 "Analogue Mix Right", "Digital Mono Mix"};
194 static const char *wm8753_adc_hp[] = {"3.4Hz @ 48kHz", "82Hz @ 16k",
195 "82Hz @ 8kHz", "170Hz @ 8kHz"};
196 static const char *wm8753_adc_filter[] = {"HiFi", "Voice"};
197 static const char *wm8753_mic_sel[] = {"Mic 1", "Mic 2", "Mic 3"};
198 static const char *wm8753_dai_mode[] = {"DAI 0", "DAI 1", "DAI 2", "DAI 3"};
199 static const char *wm8753_dat_sel[] = {"Stereo", "Left ADC", "Right ADC",
201 static const char *wm8753_rout2_phase[] = {"Non Inverted", "Inverted"};
203 static const struct soc_enum wm8753_enum[] = {
204 SOC_ENUM_SINGLE(WM8753_BASS, 7, 2, wm8753_base),
205 SOC_ENUM_SINGLE(WM8753_BASS, 4, 6, wm8753_base_filter),
206 SOC_ENUM_SINGLE(WM8753_TREBLE, 6, 2, wm8753_treble),
207 SOC_ENUM_SINGLE(WM8753_ALC1, 7, 4, wm8753_alc_func),
208 SOC_ENUM_SINGLE(WM8753_NGATE, 1, 2, wm8753_ng_type),
209 SOC_ENUM_SINGLE(WM8753_3D, 7, 2, wm8753_3d_func),
210 SOC_ENUM_SINGLE(WM8753_3D, 6, 2, wm8753_3d_uc),
211 SOC_ENUM_SINGLE(WM8753_3D, 5, 2, wm8753_3d_lc),
212 SOC_ENUM_SINGLE(WM8753_DAC, 1, 4, wm8753_deemp),
213 SOC_ENUM_SINGLE(WM8753_DAC, 4, 4, wm8753_mono_mix),
214 SOC_ENUM_SINGLE(WM8753_DAC, 6, 2, wm8753_dac_phase),
215 SOC_ENUM_SINGLE(WM8753_INCTL1, 3, 4, wm8753_line_mix),
216 SOC_ENUM_SINGLE(WM8753_INCTL1, 2, 2, wm8753_mono_mux),
217 SOC_ENUM_SINGLE(WM8753_INCTL1, 1, 2, wm8753_right_mux),
218 SOC_ENUM_SINGLE(WM8753_INCTL1, 0, 2, wm8753_left_mux),
219 SOC_ENUM_SINGLE(WM8753_INCTL2, 6, 4, wm8753_rxmsel),
220 SOC_ENUM_SINGLE(WM8753_INCTL2, 4, 4, wm8753_sidetone_mux),
221 SOC_ENUM_SINGLE(WM8753_OUTCTL, 7, 4, wm8753_mono2_src),
222 SOC_ENUM_SINGLE(WM8753_OUTCTL, 0, 3, wm8753_out3),
223 SOC_ENUM_SINGLE(WM8753_ADCTL2, 7, 3, wm8753_out4),
224 SOC_ENUM_SINGLE(WM8753_ADCIN, 2, 3, wm8753_radcsel),
225 SOC_ENUM_SINGLE(WM8753_ADCIN, 0, 3, wm8753_ladcsel),
226 SOC_ENUM_SINGLE(WM8753_ADCIN, 4, 4, wm8753_mono_adc),
227 SOC_ENUM_SINGLE(WM8753_ADC, 2, 4, wm8753_adc_hp),
228 SOC_ENUM_SINGLE(WM8753_ADC, 4, 2, wm8753_adc_filter),
229 SOC_ENUM_SINGLE(WM8753_MICBIAS, 6, 3, wm8753_mic_sel),
230 SOC_ENUM_SINGLE(WM8753_IOCTL, 2, 4, wm8753_dai_mode),
231 SOC_ENUM_SINGLE(WM8753_ADC, 7, 4, wm8753_dat_sel),
232 SOC_ENUM_SINGLE(WM8753_OUTCTL, 2, 2, wm8753_rout2_phase),
236 static int wm8753_get_dai(struct snd_kcontrol *kcontrol,
237 struct snd_ctl_elem_value *ucontrol)
239 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
240 int mode = wm8753_read_reg_cache(codec, WM8753_IOCTL);
242 ucontrol->value.integer.value[0] = (mode & 0xc) >> 2;
246 static int wm8753_set_dai(struct snd_kcontrol *kcontrol,
247 struct snd_ctl_elem_value *ucontrol)
249 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
250 int mode = wm8753_read_reg_cache(codec, WM8753_IOCTL);
252 if (((mode & 0xc) >> 2) == ucontrol->value.integer.value[0])
256 mode |= (ucontrol->value.integer.value[0] << 2);
258 wm8753_write(codec, WM8753_IOCTL, mode);
259 wm8753_set_dai_mode(codec, ucontrol->value.integer.value[0]);
263 static const DECLARE_TLV_DB_SCALE(rec_mix_tlv, -1500, 300, 0);
264 static const DECLARE_TLV_DB_SCALE(mic_preamp_tlv, 1200, 600, 0);
265 static const DECLARE_TLV_DB_SCALE(adc_tlv, -9750, 50, 1);
266 static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
267 static const unsigned int out_tlv[] = {
268 TLV_DB_RANGE_HEAD(2),
269 /* 0000000 - 0101111 = "Analogue mute" */
270 0, 48, TLV_DB_SCALE_ITEM(-25500, 0, 0),
271 48, 127, TLV_DB_SCALE_ITEM(-7300, 100, 0),
273 static const DECLARE_TLV_DB_SCALE(mix_tlv, -1500, 300, 0);
274 static const DECLARE_TLV_DB_SCALE(voice_mix_tlv, -1200, 300, 0);
275 static const DECLARE_TLV_DB_SCALE(pga_tlv, -1725, 75, 0);
277 static const struct snd_kcontrol_new wm8753_snd_controls[] = {
278 SOC_DOUBLE_R_TLV("PCM Volume", WM8753_LDAC, WM8753_RDAC, 0, 255, 0, dac_tlv),
280 SOC_DOUBLE_R_TLV("ADC Capture Volume", WM8753_LADC, WM8753_RADC, 0, 255, 0,
283 SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8753_LOUT1V, WM8753_ROUT1V,
285 SOC_DOUBLE_R_TLV("Speaker Playback Volume", WM8753_LOUT2V, WM8753_ROUT2V, 0,
288 SOC_SINGLE_TLV("Mono Playback Volume", WM8753_MOUTV, 0, 127, 0, out_tlv),
290 SOC_DOUBLE_R_TLV("Bypass Playback Volume", WM8753_LOUTM1, WM8753_ROUTM1, 4, 7,
292 SOC_DOUBLE_R_TLV("Sidetone Playback Volume", WM8753_LOUTM2, WM8753_ROUTM2, 4,
294 SOC_DOUBLE_R_TLV("Voice Playback Volume", WM8753_LOUTM2, WM8753_ROUTM2, 0, 7,
297 SOC_DOUBLE_R("Headphone Playback ZC Switch", WM8753_LOUT1V, WM8753_ROUT1V, 7,
299 SOC_DOUBLE_R("Speaker Playback ZC Switch", WM8753_LOUT2V, WM8753_ROUT2V, 7,
302 SOC_SINGLE_TLV("Mono Bypass Playback Volume", WM8753_MOUTM1, 4, 7, 1, mix_tlv),
303 SOC_SINGLE_TLV("Mono Sidetone Playback Volume", WM8753_MOUTM2, 4, 7, 1,
305 SOC_SINGLE_TLV("Mono Voice Playback Volume", WM8753_MOUTM2, 0, 7, 1,
307 SOC_SINGLE("Mono Playback ZC Switch", WM8753_MOUTV, 7, 1, 0),
309 SOC_ENUM("Bass Boost", wm8753_enum[0]),
310 SOC_ENUM("Bass Filter", wm8753_enum[1]),
311 SOC_SINGLE("Bass Volume", WM8753_BASS, 0, 15, 1),
313 SOC_SINGLE("Treble Volume", WM8753_TREBLE, 0, 15, 1),
314 SOC_ENUM("Treble Cut-off", wm8753_enum[2]),
316 SOC_DOUBLE_TLV("Sidetone Capture Volume", WM8753_RECMIX1, 0, 4, 7, 1,
318 SOC_SINGLE_TLV("Voice Sidetone Capture Volume", WM8753_RECMIX2, 0, 7, 1,
321 SOC_DOUBLE_R_TLV("Capture Volume", WM8753_LINVOL, WM8753_RINVOL, 0, 63, 0,
323 SOC_DOUBLE_R("Capture ZC Switch", WM8753_LINVOL, WM8753_RINVOL, 6, 1, 0),
324 SOC_DOUBLE_R("Capture Switch", WM8753_LINVOL, WM8753_RINVOL, 7, 1, 1),
326 SOC_ENUM("Capture Filter Select", wm8753_enum[23]),
327 SOC_ENUM("Capture Filter Cut-off", wm8753_enum[24]),
328 SOC_SINGLE("Capture Filter Switch", WM8753_ADC, 0, 1, 1),
330 SOC_SINGLE("ALC Capture Target Volume", WM8753_ALC1, 0, 7, 0),
331 SOC_SINGLE("ALC Capture Max Volume", WM8753_ALC1, 4, 7, 0),
332 SOC_ENUM("ALC Capture Function", wm8753_enum[3]),
333 SOC_SINGLE("ALC Capture ZC Switch", WM8753_ALC2, 8, 1, 0),
334 SOC_SINGLE("ALC Capture Hold Time", WM8753_ALC2, 0, 15, 1),
335 SOC_SINGLE("ALC Capture Decay Time", WM8753_ALC3, 4, 15, 1),
336 SOC_SINGLE("ALC Capture Attack Time", WM8753_ALC3, 0, 15, 0),
337 SOC_SINGLE("ALC Capture NG Threshold", WM8753_NGATE, 3, 31, 0),
338 SOC_ENUM("ALC Capture NG Type", wm8753_enum[4]),
339 SOC_SINGLE("ALC Capture NG Switch", WM8753_NGATE, 0, 1, 0),
341 SOC_ENUM("3D Function", wm8753_enum[5]),
342 SOC_ENUM("3D Upper Cut-off", wm8753_enum[6]),
343 SOC_ENUM("3D Lower Cut-off", wm8753_enum[7]),
344 SOC_SINGLE("3D Volume", WM8753_3D, 1, 15, 0),
345 SOC_SINGLE("3D Switch", WM8753_3D, 0, 1, 0),
347 SOC_SINGLE("Capture 6dB Attenuate", WM8753_ADCTL1, 2, 1, 0),
348 SOC_SINGLE("Playback 6dB Attenuate", WM8753_ADCTL1, 1, 1, 0),
350 SOC_ENUM("De-emphasis", wm8753_enum[8]),
351 SOC_ENUM("Playback Mono Mix", wm8753_enum[9]),
352 SOC_ENUM("Playback Phase", wm8753_enum[10]),
354 SOC_SINGLE_TLV("Mic2 Capture Volume", WM8753_INCTL1, 7, 3, 0, mic_preamp_tlv),
355 SOC_SINGLE_TLV("Mic1 Capture Volume", WM8753_INCTL1, 5, 3, 0, mic_preamp_tlv),
357 SOC_ENUM_EXT("DAI Mode", wm8753_enum[26], wm8753_get_dai, wm8753_set_dai),
359 SOC_ENUM("ADC Data Select", wm8753_enum[27]),
360 SOC_ENUM("ROUT2 Phase", wm8753_enum[28]),
363 /* add non dapm controls */
364 static int wm8753_add_controls(struct snd_soc_codec *codec)
368 for (i = 0; i < ARRAY_SIZE(wm8753_snd_controls); i++) {
369 err = snd_ctl_add(codec->card,
370 snd_soc_cnew(&wm8753_snd_controls[i],
383 static const struct snd_kcontrol_new wm8753_left_mixer_controls[] = {
384 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_LOUTM2, 8, 1, 0),
385 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_LOUTM2, 7, 1, 0),
386 SOC_DAPM_SINGLE("Left Playback Switch", WM8753_LOUTM1, 8, 1, 0),
387 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_LOUTM1, 7, 1, 0),
391 static const struct snd_kcontrol_new wm8753_right_mixer_controls[] = {
392 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_ROUTM2, 8, 1, 0),
393 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_ROUTM2, 7, 1, 0),
394 SOC_DAPM_SINGLE("Right Playback Switch", WM8753_ROUTM1, 8, 1, 0),
395 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_ROUTM1, 7, 1, 0),
399 static const struct snd_kcontrol_new wm8753_mono_mixer_controls[] = {
400 SOC_DAPM_SINGLE("Left Playback Switch", WM8753_MOUTM1, 8, 1, 0),
401 SOC_DAPM_SINGLE("Right Playback Switch", WM8753_MOUTM2, 8, 1, 0),
402 SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_MOUTM2, 3, 1, 0),
403 SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_MOUTM2, 7, 1, 0),
404 SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_MOUTM1, 7, 1, 0),
408 static const struct snd_kcontrol_new wm8753_mono2_controls =
409 SOC_DAPM_ENUM("Route", wm8753_enum[17]);
412 static const struct snd_kcontrol_new wm8753_out3_controls =
413 SOC_DAPM_ENUM("Route", wm8753_enum[18]);
416 static const struct snd_kcontrol_new wm8753_out4_controls =
417 SOC_DAPM_ENUM("Route", wm8753_enum[19]);
420 static const struct snd_kcontrol_new wm8753_adc_mono_controls =
421 SOC_DAPM_ENUM("Route", wm8753_enum[22]);
424 static const struct snd_kcontrol_new wm8753_record_mixer_controls[] = {
425 SOC_DAPM_SINGLE("Voice Capture Switch", WM8753_RECMIX2, 3, 1, 0),
426 SOC_DAPM_SINGLE("Left Capture Switch", WM8753_RECMIX1, 3, 1, 0),
427 SOC_DAPM_SINGLE("Right Capture Switch", WM8753_RECMIX1, 7, 1, 0),
431 static const struct snd_kcontrol_new wm8753_adc_left_controls =
432 SOC_DAPM_ENUM("Route", wm8753_enum[21]);
435 static const struct snd_kcontrol_new wm8753_adc_right_controls =
436 SOC_DAPM_ENUM("Route", wm8753_enum[20]);
439 static const struct snd_kcontrol_new wm8753_mic_mux_controls =
440 SOC_DAPM_ENUM("Route", wm8753_enum[16]);
443 static const struct snd_kcontrol_new wm8753_alc_mixer_controls[] = {
444 SOC_DAPM_SINGLE("Line Capture Switch", WM8753_INCTL2, 3, 1, 0),
445 SOC_DAPM_SINGLE("Mic2 Capture Switch", WM8753_INCTL2, 2, 1, 0),
446 SOC_DAPM_SINGLE("Mic1 Capture Switch", WM8753_INCTL2, 1, 1, 0),
447 SOC_DAPM_SINGLE("Rx Capture Switch", WM8753_INCTL2, 0, 1, 0),
451 static const struct snd_kcontrol_new wm8753_line_left_controls =
452 SOC_DAPM_ENUM("Route", wm8753_enum[14]);
455 static const struct snd_kcontrol_new wm8753_line_right_controls =
456 SOC_DAPM_ENUM("Route", wm8753_enum[13]);
459 static const struct snd_kcontrol_new wm8753_line_mono_controls =
460 SOC_DAPM_ENUM("Route", wm8753_enum[12]);
462 /* Line mux and mixer */
463 static const struct snd_kcontrol_new wm8753_line_mux_mix_controls =
464 SOC_DAPM_ENUM("Route", wm8753_enum[11]);
466 /* Rx mux and mixer */
467 static const struct snd_kcontrol_new wm8753_rx_mux_mix_controls =
468 SOC_DAPM_ENUM("Route", wm8753_enum[15]);
470 /* Mic Selector Mux */
471 static const struct snd_kcontrol_new wm8753_mic_sel_mux_controls =
472 SOC_DAPM_ENUM("Route", wm8753_enum[25]);
474 static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
475 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8753_PWR1, 5, 0),
476 SND_SOC_DAPM_MIXER("Left Mixer", WM8753_PWR4, 0, 0,
477 &wm8753_left_mixer_controls[0], ARRAY_SIZE(wm8753_left_mixer_controls)),
478 SND_SOC_DAPM_PGA("Left Out 1", WM8753_PWR3, 8, 0, NULL, 0),
479 SND_SOC_DAPM_PGA("Left Out 2", WM8753_PWR3, 6, 0, NULL, 0),
480 SND_SOC_DAPM_DAC("Left DAC", "Left HiFi Playback", WM8753_PWR1, 3, 0),
481 SND_SOC_DAPM_OUTPUT("LOUT1"),
482 SND_SOC_DAPM_OUTPUT("LOUT2"),
483 SND_SOC_DAPM_MIXER("Right Mixer", WM8753_PWR4, 1, 0,
484 &wm8753_right_mixer_controls[0], ARRAY_SIZE(wm8753_right_mixer_controls)),
485 SND_SOC_DAPM_PGA("Right Out 1", WM8753_PWR3, 7, 0, NULL, 0),
486 SND_SOC_DAPM_PGA("Right Out 2", WM8753_PWR3, 5, 0, NULL, 0),
487 SND_SOC_DAPM_DAC("Right DAC", "Right HiFi Playback", WM8753_PWR1, 2, 0),
488 SND_SOC_DAPM_OUTPUT("ROUT1"),
489 SND_SOC_DAPM_OUTPUT("ROUT2"),
490 SND_SOC_DAPM_MIXER("Mono Mixer", WM8753_PWR4, 2, 0,
491 &wm8753_mono_mixer_controls[0], ARRAY_SIZE(wm8753_mono_mixer_controls)),
492 SND_SOC_DAPM_PGA("Mono Out 1", WM8753_PWR3, 2, 0, NULL, 0),
493 SND_SOC_DAPM_PGA("Mono Out 2", WM8753_PWR3, 1, 0, NULL, 0),
494 SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", WM8753_PWR1, 4, 0),
495 SND_SOC_DAPM_OUTPUT("MONO1"),
496 SND_SOC_DAPM_MUX("Mono 2 Mux", SND_SOC_NOPM, 0, 0, &wm8753_mono2_controls),
497 SND_SOC_DAPM_OUTPUT("MONO2"),
498 SND_SOC_DAPM_MIXER("Out3 Left + Right", -1, 0, 0, NULL, 0),
499 SND_SOC_DAPM_MUX("Out3 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out3_controls),
500 SND_SOC_DAPM_PGA("Out 3", WM8753_PWR3, 4, 0, NULL, 0),
501 SND_SOC_DAPM_OUTPUT("OUT3"),
502 SND_SOC_DAPM_MUX("Out4 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out4_controls),
503 SND_SOC_DAPM_PGA("Out 4", WM8753_PWR3, 3, 0, NULL, 0),
504 SND_SOC_DAPM_OUTPUT("OUT4"),
505 SND_SOC_DAPM_MIXER("Playback Mixer", WM8753_PWR4, 3, 0,
506 &wm8753_record_mixer_controls[0],
507 ARRAY_SIZE(wm8753_record_mixer_controls)),
508 SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8753_PWR2, 3, 0),
509 SND_SOC_DAPM_ADC("Right ADC", "Right Capture", WM8753_PWR2, 2, 0),
510 SND_SOC_DAPM_MUX("Capture Left Mixer", SND_SOC_NOPM, 0, 0,
511 &wm8753_adc_mono_controls),
512 SND_SOC_DAPM_MUX("Capture Right Mixer", SND_SOC_NOPM, 0, 0,
513 &wm8753_adc_mono_controls),
514 SND_SOC_DAPM_MUX("Capture Left Mux", SND_SOC_NOPM, 0, 0,
515 &wm8753_adc_left_controls),
516 SND_SOC_DAPM_MUX("Capture Right Mux", SND_SOC_NOPM, 0, 0,
517 &wm8753_adc_right_controls),
518 SND_SOC_DAPM_MUX("Mic Sidetone Mux", SND_SOC_NOPM, 0, 0,
519 &wm8753_mic_mux_controls),
520 SND_SOC_DAPM_PGA("Left Capture Volume", WM8753_PWR2, 5, 0, NULL, 0),
521 SND_SOC_DAPM_PGA("Right Capture Volume", WM8753_PWR2, 4, 0, NULL, 0),
522 SND_SOC_DAPM_MIXER("ALC Mixer", WM8753_PWR2, 6, 0,
523 &wm8753_alc_mixer_controls[0], ARRAY_SIZE(wm8753_alc_mixer_controls)),
524 SND_SOC_DAPM_MUX("Line Left Mux", SND_SOC_NOPM, 0, 0,
525 &wm8753_line_left_controls),
526 SND_SOC_DAPM_MUX("Line Right Mux", SND_SOC_NOPM, 0, 0,
527 &wm8753_line_right_controls),
528 SND_SOC_DAPM_MUX("Line Mono Mux", SND_SOC_NOPM, 0, 0,
529 &wm8753_line_mono_controls),
530 SND_SOC_DAPM_MUX("Line Mixer", WM8753_PWR2, 0, 0,
531 &wm8753_line_mux_mix_controls),
532 SND_SOC_DAPM_MUX("Rx Mixer", WM8753_PWR2, 1, 0,
533 &wm8753_rx_mux_mix_controls),
534 SND_SOC_DAPM_PGA("Mic 1 Volume", WM8753_PWR2, 8, 0, NULL, 0),
535 SND_SOC_DAPM_PGA("Mic 2 Volume", WM8753_PWR2, 7, 0, NULL, 0),
536 SND_SOC_DAPM_MUX("Mic Selection Mux", SND_SOC_NOPM, 0, 0,
537 &wm8753_mic_sel_mux_controls),
538 SND_SOC_DAPM_INPUT("LINE1"),
539 SND_SOC_DAPM_INPUT("LINE2"),
540 SND_SOC_DAPM_INPUT("RXP"),
541 SND_SOC_DAPM_INPUT("RXN"),
542 SND_SOC_DAPM_INPUT("ACIN"),
543 SND_SOC_DAPM_OUTPUT("ACOP"),
544 SND_SOC_DAPM_INPUT("MIC1N"),
545 SND_SOC_DAPM_INPUT("MIC1"),
546 SND_SOC_DAPM_INPUT("MIC2N"),
547 SND_SOC_DAPM_INPUT("MIC2"),
548 SND_SOC_DAPM_VMID("VREF"),
551 static const struct snd_soc_dapm_route audio_map[] = {
553 {"Left Mixer", "Left Playback Switch", "Left DAC"},
554 {"Left Mixer", "Voice Playback Switch", "Voice DAC"},
555 {"Left Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
556 {"Left Mixer", "Bypass Playback Switch", "Line Left Mux"},
559 {"Right Mixer", "Right Playback Switch", "Right DAC"},
560 {"Right Mixer", "Voice Playback Switch", "Voice DAC"},
561 {"Right Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
562 {"Right Mixer", "Bypass Playback Switch", "Line Right Mux"},
565 {"Mono Mixer", "Voice Playback Switch", "Voice DAC"},
566 {"Mono Mixer", "Left Playback Switch", "Left DAC"},
567 {"Mono Mixer", "Right Playback Switch", "Right DAC"},
568 {"Mono Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
569 {"Mono Mixer", "Bypass Playback Switch", "Line Mono Mux"},
572 {"Left Out 1", NULL, "Left Mixer"},
573 {"Left Out 2", NULL, "Left Mixer"},
574 {"LOUT1", NULL, "Left Out 1"},
575 {"LOUT2", NULL, "Left Out 2"},
578 {"Right Out 1", NULL, "Right Mixer"},
579 {"Right Out 2", NULL, "Right Mixer"},
580 {"ROUT1", NULL, "Right Out 1"},
581 {"ROUT2", NULL, "Right Out 2"},
584 {"Mono Out 1", NULL, "Mono Mixer"},
585 {"MONO1", NULL, "Mono Out 1"},
588 {"Mono 2 Mux", "Left + Right", "Out3 Left + Right"},
589 {"Mono 2 Mux", "Inverted Mono 1", "MONO1"},
590 {"Mono 2 Mux", "Left", "Left Mixer"},
591 {"Mono 2 Mux", "Right", "Right Mixer"},
592 {"Mono Out 2", NULL, "Mono 2 Mux"},
593 {"MONO2", NULL, "Mono Out 2"},
596 {"Out3 Left + Right", NULL, "Left Mixer"},
597 {"Out3 Left + Right", NULL, "Right Mixer"},
598 {"Out3 Mux", "VREF", "VREF"},
599 {"Out3 Mux", "Left + Right", "Out3 Left + Right"},
600 {"Out3 Mux", "ROUT2", "ROUT2"},
601 {"Out 3", NULL, "Out3 Mux"},
602 {"OUT3", NULL, "Out 3"},
605 {"Out4 Mux", "VREF", "VREF"},
606 {"Out4 Mux", "Capture ST", "Capture ST Mixer"},
607 {"Out4 Mux", "LOUT2", "LOUT2"},
608 {"Out 4", NULL, "Out4 Mux"},
609 {"OUT4", NULL, "Out 4"},
612 {"Playback Mixer", "Left Capture Switch", "Left Mixer"},
613 {"Playback Mixer", "Voice Capture Switch", "Mono Mixer"},
614 {"Playback Mixer", "Right Capture Switch", "Right Mixer"},
616 /* Mic/SideTone Mux */
617 {"Mic Sidetone Mux", "Left PGA", "Left Capture Volume"},
618 {"Mic Sidetone Mux", "Right PGA", "Right Capture Volume"},
619 {"Mic Sidetone Mux", "Mic 1", "Mic 1 Volume"},
620 {"Mic Sidetone Mux", "Mic 2", "Mic 2 Volume"},
622 /* Capture Left Mux */
623 {"Capture Left Mux", "PGA", "Left Capture Volume"},
624 {"Capture Left Mux", "Line or RXP-RXN", "Line Left Mux"},
625 {"Capture Left Mux", "Line", "LINE1"},
627 /* Capture Right Mux */
628 {"Capture Right Mux", "PGA", "Right Capture Volume"},
629 {"Capture Right Mux", "Line or RXP-RXN", "Line Right Mux"},
630 {"Capture Right Mux", "Sidetone", "Capture ST Mixer"},
632 /* Mono Capture mixer-mux */
633 {"Capture Right Mixer", "Stereo", "Capture Right Mux"},
634 {"Capture Left Mixer", "Analogue Mix Left", "Capture Left Mux"},
635 {"Capture Left Mixer", "Analogue Mix Left", "Capture Right Mux"},
636 {"Capture Right Mixer", "Analogue Mix Right", "Capture Left Mux"},
637 {"Capture Right Mixer", "Analogue Mix Right", "Capture Right Mux"},
638 {"Capture Left Mixer", "Digital Mono Mix", "Capture Left Mux"},
639 {"Capture Left Mixer", "Digital Mono Mix", "Capture Right Mux"},
640 {"Capture Right Mixer", "Digital Mono Mix", "Capture Left Mux"},
641 {"Capture Right Mixer", "Digital Mono Mix", "Capture Right Mux"},
644 {"Left ADC", NULL, "Capture Left Mixer"},
645 {"Right ADC", NULL, "Capture Right Mixer"},
647 /* Left Capture Volume */
648 {"Left Capture Volume", NULL, "ACIN"},
650 /* Right Capture Volume */
651 {"Right Capture Volume", NULL, "Mic 2 Volume"},
654 {"ALC Mixer", "Line Capture Switch", "Line Mixer"},
655 {"ALC Mixer", "Mic2 Capture Switch", "Mic 2 Volume"},
656 {"ALC Mixer", "Mic1 Capture Switch", "Mic 1 Volume"},
657 {"ALC Mixer", "Rx Capture Switch", "Rx Mixer"},
660 {"Line Left Mux", "Line 1", "LINE1"},
661 {"Line Left Mux", "Rx Mix", "Rx Mixer"},
664 {"Line Right Mux", "Line 2", "LINE2"},
665 {"Line Right Mux", "Rx Mix", "Rx Mixer"},
668 {"Line Mono Mux", "Line Mix", "Line Mixer"},
669 {"Line Mono Mux", "Rx Mix", "Rx Mixer"},
672 {"Line Mixer", "Line 1 + 2", "LINE1"},
673 {"Line Mixer", "Line 1 - 2", "LINE1"},
674 {"Line Mixer", "Line 1 + 2", "LINE2"},
675 {"Line Mixer", "Line 1 - 2", "LINE2"},
676 {"Line Mixer", "Line 1", "LINE1"},
677 {"Line Mixer", "Line 2", "LINE2"},
680 {"Rx Mixer", "RXP - RXN", "RXP"},
681 {"Rx Mixer", "RXP + RXN", "RXP"},
682 {"Rx Mixer", "RXP - RXN", "RXN"},
683 {"Rx Mixer", "RXP + RXN", "RXN"},
684 {"Rx Mixer", "RXP", "RXP"},
685 {"Rx Mixer", "RXN", "RXN"},
688 {"Mic 1 Volume", NULL, "MIC1N"},
689 {"Mic 1 Volume", NULL, "Mic Selection Mux"},
692 {"Mic 2 Volume", NULL, "MIC2N"},
693 {"Mic 2 Volume", NULL, "MIC2"},
695 /* Mic Selector Mux */
696 {"Mic Selection Mux", "Mic 1", "MIC1"},
697 {"Mic Selection Mux", "Mic 2", "MIC2N"},
698 {"Mic Selection Mux", "Mic 3", "MIC2"},
701 {"ACOP", NULL, "ALC Mixer"},
704 static int wm8753_add_widgets(struct snd_soc_codec *codec)
706 snd_soc_dapm_new_controls(codec, wm8753_dapm_widgets,
707 ARRAY_SIZE(wm8753_dapm_widgets));
709 snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
711 snd_soc_dapm_new_widgets(codec);
722 /* The size in bits of the pll divide multiplied by 10
723 * to allow rounding later */
724 #define FIXED_PLL_SIZE ((1 << 22) * 10)
726 static void pll_factors(struct _pll_div *pll_div, unsigned int target,
730 unsigned int K, Ndiv, Nmod;
732 Ndiv = target / source;
736 Ndiv = target / source;
740 if ((Ndiv < 6) || (Ndiv > 12))
742 "wm8753: unsupported N = %d\n", Ndiv);
745 Nmod = target % source;
746 Kpart = FIXED_PLL_SIZE * (long long)Nmod;
748 do_div(Kpart, source);
750 K = Kpart & 0xFFFFFFFF;
752 /* Check if we need to round */
756 /* Move down to proper range now rounding is done */
762 static int wm8753_set_dai_pll(struct snd_soc_codec_dai *codec_dai,
763 int pll_id, unsigned int freq_in, unsigned int freq_out)
767 struct snd_soc_codec *codec = codec_dai->codec;
769 if (pll_id < WM8753_PLL1 || pll_id > WM8753_PLL2)
772 if (pll_id == WM8753_PLL1) {
775 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xffef;
779 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfff7;
782 if (!freq_in || !freq_out) {
784 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0026);
785 wm8753_write(codec, WM8753_CLOCK, reg);
789 struct _pll_div pll_div;
791 pll_factors(&pll_div, freq_out * 8, freq_in);
793 /* set up N and K PLL divisor ratios */
794 /* bits 8:5 = PLL_N, bits 3:0 = PLL_K[21:18] */
795 value = (pll_div.n << 5) + ((pll_div.k & 0x3c0000) >> 18);
796 wm8753_write(codec, WM8753_PLL1CTL2 + offset, value);
798 /* bits 8:0 = PLL_K[17:9] */
799 value = (pll_div.k & 0x03fe00) >> 9;
800 wm8753_write(codec, WM8753_PLL1CTL3 + offset, value);
802 /* bits 8:0 = PLL_K[8:0] */
803 value = pll_div.k & 0x0001ff;
804 wm8753_write(codec, WM8753_PLL1CTL4 + offset, value);
806 /* set PLL as input and enable */
807 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0027 |
808 (pll_div.div2 << 3));
809 wm8753_write(codec, WM8753_CLOCK, reg | enable);
821 /* codec hifi mclk (after PLL) clock divider coefficients */
822 static const struct _coeff_div coeff_div[] = {
824 {12288000, 8000, 0x6, 0x0},
825 {11289600, 8000, 0x16, 0x0},
826 {18432000, 8000, 0x7, 0x0},
827 {16934400, 8000, 0x17, 0x0},
828 {12000000, 8000, 0x6, 0x1},
831 {11289600, 11025, 0x18, 0x0},
832 {16934400, 11025, 0x19, 0x0},
833 {12000000, 11025, 0x19, 0x1},
836 {12288000, 16000, 0xa, 0x0},
837 {18432000, 16000, 0xb, 0x0},
838 {12000000, 16000, 0xa, 0x1},
841 {11289600, 22050, 0x1a, 0x0},
842 {16934400, 22050, 0x1b, 0x0},
843 {12000000, 22050, 0x1b, 0x1},
846 {12288000, 32000, 0xc, 0x0},
847 {18432000, 32000, 0xd, 0x0},
848 {12000000, 32000, 0xa, 0x1},
851 {11289600, 44100, 0x10, 0x0},
852 {16934400, 44100, 0x11, 0x0},
853 {12000000, 44100, 0x11, 0x1},
856 {12288000, 48000, 0x0, 0x0},
857 {18432000, 48000, 0x1, 0x0},
858 {12000000, 48000, 0x0, 0x1},
861 {11289600, 88200, 0x1e, 0x0},
862 {16934400, 88200, 0x1f, 0x0},
863 {12000000, 88200, 0x1f, 0x1},
866 {12288000, 96000, 0xe, 0x0},
867 {18432000, 96000, 0xf, 0x0},
868 {12000000, 96000, 0xe, 0x1},
871 static int get_coeff(int mclk, int rate)
875 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
876 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
883 * Clock after PLL and dividers
885 static int wm8753_set_dai_sysclk(struct snd_soc_codec_dai *codec_dai,
886 int clk_id, unsigned int freq, int dir)
888 struct snd_soc_codec *codec = codec_dai->codec;
889 struct wm8753_priv *wm8753 = codec->private_data;
897 if (clk_id == WM8753_MCLK) {
898 wm8753->sysclk = freq;
900 } else if (clk_id == WM8753_PCMCLK) {
901 wm8753->pcmclk = freq;
910 * Set's ADC and Voice DAC format.
912 static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
915 struct snd_soc_codec *codec = codec_dai->codec;
916 u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01ec;
918 /* interface format */
919 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
920 case SND_SOC_DAIFMT_I2S:
923 case SND_SOC_DAIFMT_RIGHT_J:
925 case SND_SOC_DAIFMT_LEFT_J:
928 case SND_SOC_DAIFMT_DSP_A:
931 case SND_SOC_DAIFMT_DSP_B:
938 wm8753_write(codec, WM8753_PCM, voice);
943 * Set PCM DAI bit size and sample rate.
945 static int wm8753_pcm_hw_params(struct snd_pcm_substream *substream,
946 struct snd_pcm_hw_params *params)
948 struct snd_soc_pcm_runtime *rtd = substream->private_data;
949 struct snd_soc_device *socdev = rtd->socdev;
950 struct snd_soc_codec *codec = socdev->codec;
951 struct wm8753_priv *wm8753 = codec->private_data;
952 u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01f3;
953 u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x017f;
956 switch (params_format(params)) {
957 case SNDRV_PCM_FORMAT_S16_LE:
959 case SNDRV_PCM_FORMAT_S20_3LE:
962 case SNDRV_PCM_FORMAT_S24_LE:
965 case SNDRV_PCM_FORMAT_S32_LE:
971 if (params_rate(params) * 384 == wm8753->pcmclk)
973 wm8753_write(codec, WM8753_SRATE1, srate);
975 wm8753_write(codec, WM8753_PCM, voice);
980 * Set's PCM dai fmt and BCLK.
982 static int wm8753_pcm_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
985 struct snd_soc_codec *codec = codec_dai->codec;
988 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x011f;
989 ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x015d;
991 /* set master/slave audio interface */
992 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
993 case SND_SOC_DAIFMT_CBS_CFS:
995 case SND_SOC_DAIFMT_CBM_CFM:
997 case SND_SOC_DAIFMT_CBM_CFS:
1004 /* clock inversion */
1005 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1006 case SND_SOC_DAIFMT_DSP_A:
1007 case SND_SOC_DAIFMT_DSP_B:
1008 /* frame inversion not valid for DSP modes */
1009 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1010 case SND_SOC_DAIFMT_NB_NF:
1012 case SND_SOC_DAIFMT_IB_NF:
1019 case SND_SOC_DAIFMT_I2S:
1020 case SND_SOC_DAIFMT_RIGHT_J:
1021 case SND_SOC_DAIFMT_LEFT_J:
1023 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1024 case SND_SOC_DAIFMT_NB_NF:
1026 case SND_SOC_DAIFMT_IB_IF:
1029 case SND_SOC_DAIFMT_IB_NF:
1032 case SND_SOC_DAIFMT_NB_IF:
1043 wm8753_write(codec, WM8753_PCM, voice);
1044 wm8753_write(codec, WM8753_IOCTL, ioctl);
1048 static int wm8753_set_dai_clkdiv(struct snd_soc_codec_dai *codec_dai,
1049 int div_id, int div)
1051 struct snd_soc_codec *codec = codec_dai->codec;
1056 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0x003f;
1057 wm8753_write(codec, WM8753_CLOCK, reg | div);
1059 case WM8753_BCLKDIV:
1060 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x01c7;
1061 wm8753_write(codec, WM8753_SRATE2, reg | div);
1063 case WM8753_VXCLKDIV:
1064 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x003f;
1065 wm8753_write(codec, WM8753_SRATE2, reg | div);
1074 * Set's HiFi DAC format.
1076 static int wm8753_hdac_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1079 struct snd_soc_codec *codec = codec_dai->codec;
1080 u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01e0;
1082 /* interface format */
1083 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1084 case SND_SOC_DAIFMT_I2S:
1087 case SND_SOC_DAIFMT_RIGHT_J:
1089 case SND_SOC_DAIFMT_LEFT_J:
1092 case SND_SOC_DAIFMT_DSP_A:
1095 case SND_SOC_DAIFMT_DSP_B:
1102 wm8753_write(codec, WM8753_HIFI, hifi);
1107 * Set's I2S DAI format.
1109 static int wm8753_i2s_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1112 struct snd_soc_codec *codec = codec_dai->codec;
1115 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x011f;
1116 ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x00ae;
1118 /* set master/slave audio interface */
1119 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1120 case SND_SOC_DAIFMT_CBS_CFS:
1122 case SND_SOC_DAIFMT_CBM_CFM:
1124 case SND_SOC_DAIFMT_CBM_CFS:
1131 /* clock inversion */
1132 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1133 case SND_SOC_DAIFMT_DSP_A:
1134 case SND_SOC_DAIFMT_DSP_B:
1135 /* frame inversion not valid for DSP modes */
1136 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1137 case SND_SOC_DAIFMT_NB_NF:
1139 case SND_SOC_DAIFMT_IB_NF:
1146 case SND_SOC_DAIFMT_I2S:
1147 case SND_SOC_DAIFMT_RIGHT_J:
1148 case SND_SOC_DAIFMT_LEFT_J:
1150 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1151 case SND_SOC_DAIFMT_NB_NF:
1153 case SND_SOC_DAIFMT_IB_IF:
1156 case SND_SOC_DAIFMT_IB_NF:
1159 case SND_SOC_DAIFMT_NB_IF:
1170 wm8753_write(codec, WM8753_HIFI, hifi);
1171 wm8753_write(codec, WM8753_IOCTL, ioctl);
1176 * Set PCM DAI bit size and sample rate.
1178 static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream,
1179 struct snd_pcm_hw_params *params)
1181 struct snd_soc_pcm_runtime *rtd = substream->private_data;
1182 struct snd_soc_device *socdev = rtd->socdev;
1183 struct snd_soc_codec *codec = socdev->codec;
1184 struct wm8753_priv *wm8753 = codec->private_data;
1185 u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x01c0;
1186 u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01f3;
1189 /* is digital filter coefficient valid ? */
1190 coeff = get_coeff(wm8753->sysclk, params_rate(params));
1192 printk(KERN_ERR "wm8753 invalid MCLK or rate\n");
1195 wm8753_write(codec, WM8753_SRATE1, srate | (coeff_div[coeff].sr << 1) |
1196 coeff_div[coeff].usb);
1199 switch (params_format(params)) {
1200 case SNDRV_PCM_FORMAT_S16_LE:
1202 case SNDRV_PCM_FORMAT_S20_3LE:
1205 case SNDRV_PCM_FORMAT_S24_LE:
1208 case SNDRV_PCM_FORMAT_S32_LE:
1213 wm8753_write(codec, WM8753_HIFI, hifi);
1217 static int wm8753_mode1v_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1220 struct snd_soc_codec *codec = codec_dai->codec;
1223 /* set clk source as pcmclk */
1224 clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1225 wm8753_write(codec, WM8753_CLOCK, clock);
1227 if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1229 return wm8753_pcm_set_dai_fmt(codec_dai, fmt);
1232 static int wm8753_mode1h_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1235 if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1237 return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1240 static int wm8753_mode2_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1243 struct snd_soc_codec *codec = codec_dai->codec;
1246 /* set clk source as pcmclk */
1247 clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1248 wm8753_write(codec, WM8753_CLOCK, clock);
1250 if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1252 return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1255 static int wm8753_mode3_4_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1258 struct snd_soc_codec *codec = codec_dai->codec;
1261 /* set clk source as mclk */
1262 clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1263 wm8753_write(codec, WM8753_CLOCK, clock | 0x4);
1265 if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1267 if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1269 return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1272 static int wm8753_mute(struct snd_soc_codec_dai *dai, int mute)
1274 struct snd_soc_codec *codec = dai->codec;
1275 u16 mute_reg = wm8753_read_reg_cache(codec, WM8753_DAC) & 0xfff7;
1277 /* the digital mute covers the HiFi and Voice DAC's on the WM8753.
1278 * make sure we check if they are not both active when we mute */
1279 if (mute && dai->id == 1) {
1280 if (!wm8753_dai[WM8753_DAI_VOICE].playback.active ||
1281 !wm8753_dai[WM8753_DAI_HIFI].playback.active)
1282 wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1285 wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1287 wm8753_write(codec, WM8753_DAC, mute_reg);
1293 static int wm8753_set_bias_level(struct snd_soc_codec *codec,
1294 enum snd_soc_bias_level level)
1296 u16 pwr_reg = wm8753_read_reg_cache(codec, WM8753_PWR1) & 0xfe3e;
1299 case SND_SOC_BIAS_ON:
1300 /* set vmid to 50k and unmute dac */
1301 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x00c0);
1303 case SND_SOC_BIAS_PREPARE:
1304 /* set vmid to 5k for quick power up */
1305 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
1307 case SND_SOC_BIAS_STANDBY:
1308 /* mute dac and set vmid to 500k, enable VREF */
1309 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
1311 case SND_SOC_BIAS_OFF:
1312 wm8753_write(codec, WM8753_PWR1, 0x0001);
1315 codec->bias_level = level;
1319 #define WM8753_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
1320 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
1321 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
1322 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
1324 #define WM8753_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
1325 SNDRV_PCM_FMTBIT_S24_LE)
1328 * The WM8753 supports upto 4 different and mutually exclusive DAI
1329 * configurations. This gives 2 PCM's available for use, hifi and voice.
1330 * NOTE: The Voice PCM cannot play or capture audio to the CPU as it's DAI
1331 * is connected between the wm8753 and a BT codec or GSM modem.
1333 * 1. Voice over PCM DAI - HIFI DAC over HIFI DAI
1334 * 2. Voice over HIFI DAI - HIFI disabled
1335 * 3. Voice disabled - HIFI over HIFI
1336 * 4. Voice disabled - HIFI over HIFI, uses voice DAI LRC for capture
1338 static const struct snd_soc_codec_dai wm8753_all_dai[] = {
1339 /* DAI HiFi mode 1 */
1340 { .name = "WM8753 HiFi",
1343 .stream_name = "HiFi Playback",
1346 .rates = WM8753_RATES,
1347 .formats = WM8753_FORMATS,},
1348 .capture = { /* dummy for fast DAI switching */
1349 .stream_name = "Capture",
1352 .rates = WM8753_RATES,
1353 .formats = WM8753_FORMATS,},
1355 .hw_params = wm8753_i2s_hw_params,},
1357 .digital_mute = wm8753_mute,
1358 .set_fmt = wm8753_mode1h_set_dai_fmt,
1359 .set_clkdiv = wm8753_set_dai_clkdiv,
1360 .set_pll = wm8753_set_dai_pll,
1361 .set_sysclk = wm8753_set_dai_sysclk,
1364 /* DAI Voice mode 1 */
1365 { .name = "WM8753 Voice",
1368 .stream_name = "Voice Playback",
1371 .rates = WM8753_RATES,
1372 .formats = WM8753_FORMATS,},
1374 .stream_name = "Capture",
1377 .rates = WM8753_RATES,
1378 .formats = WM8753_FORMATS,},
1380 .hw_params = wm8753_pcm_hw_params,},
1382 .digital_mute = wm8753_mute,
1383 .set_fmt = wm8753_mode1v_set_dai_fmt,
1384 .set_clkdiv = wm8753_set_dai_clkdiv,
1385 .set_pll = wm8753_set_dai_pll,
1386 .set_sysclk = wm8753_set_dai_sysclk,
1389 /* DAI HiFi mode 2 - dummy */
1390 { .name = "WM8753 HiFi",
1393 /* DAI Voice mode 2 */
1394 { .name = "WM8753 Voice",
1397 .stream_name = "Voice Playback",
1400 .rates = WM8753_RATES,
1401 .formats = WM8753_FORMATS,},
1403 .stream_name = "Capture",
1406 .rates = WM8753_RATES,
1407 .formats = WM8753_FORMATS,},
1409 .hw_params = wm8753_pcm_hw_params,},
1411 .digital_mute = wm8753_mute,
1412 .set_fmt = wm8753_mode2_set_dai_fmt,
1413 .set_clkdiv = wm8753_set_dai_clkdiv,
1414 .set_pll = wm8753_set_dai_pll,
1415 .set_sysclk = wm8753_set_dai_sysclk,
1418 /* DAI HiFi mode 3 */
1419 { .name = "WM8753 HiFi",
1422 .stream_name = "HiFi Playback",
1425 .rates = WM8753_RATES,
1426 .formats = WM8753_FORMATS,},
1428 .stream_name = "Capture",
1431 .rates = WM8753_RATES,
1432 .formats = WM8753_FORMATS,},
1434 .hw_params = wm8753_i2s_hw_params,},
1436 .digital_mute = wm8753_mute,
1437 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1438 .set_clkdiv = wm8753_set_dai_clkdiv,
1439 .set_pll = wm8753_set_dai_pll,
1440 .set_sysclk = wm8753_set_dai_sysclk,
1443 /* DAI Voice mode 3 - dummy */
1444 { .name = "WM8753 Voice",
1447 /* DAI HiFi mode 4 */
1448 { .name = "WM8753 HiFi",
1451 .stream_name = "HiFi Playback",
1454 .rates = WM8753_RATES,
1455 .formats = WM8753_FORMATS,},
1457 .stream_name = "Capture",
1460 .rates = WM8753_RATES,
1461 .formats = WM8753_FORMATS,},
1463 .hw_params = wm8753_i2s_hw_params,},
1465 .digital_mute = wm8753_mute,
1466 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1467 .set_clkdiv = wm8753_set_dai_clkdiv,
1468 .set_pll = wm8753_set_dai_pll,
1469 .set_sysclk = wm8753_set_dai_sysclk,
1472 /* DAI Voice mode 4 - dummy */
1473 { .name = "WM8753 Voice",
1478 struct snd_soc_codec_dai wm8753_dai[2];
1479 EXPORT_SYMBOL_GPL(wm8753_dai);
1481 static void wm8753_set_dai_mode(struct snd_soc_codec *codec, unsigned int mode)
1484 int playback_active, capture_active, codec_active, pop_wait;
1487 playback_active = wm8753_dai[0].playback.active;
1488 capture_active = wm8753_dai[0].capture.active;
1489 codec_active = wm8753_dai[0].active;
1490 private_data = wm8753_dai[0].private_data;
1491 pop_wait = wm8753_dai[0].pop_wait;
1492 wm8753_dai[0] = wm8753_all_dai[mode << 1];
1493 wm8753_dai[0].playback.active = playback_active;
1494 wm8753_dai[0].capture.active = capture_active;
1495 wm8753_dai[0].active = codec_active;
1496 wm8753_dai[0].private_data = private_data;
1497 wm8753_dai[0].pop_wait = pop_wait;
1499 playback_active = wm8753_dai[1].playback.active;
1500 capture_active = wm8753_dai[1].capture.active;
1501 codec_active = wm8753_dai[1].active;
1502 private_data = wm8753_dai[1].private_data;
1503 pop_wait = wm8753_dai[1].pop_wait;
1504 wm8753_dai[1] = wm8753_all_dai[(mode << 1) + 1];
1505 wm8753_dai[1].playback.active = playback_active;
1506 wm8753_dai[1].capture.active = capture_active;
1507 wm8753_dai[1].active = codec_active;
1508 wm8753_dai[1].private_data = private_data;
1509 wm8753_dai[1].pop_wait = pop_wait;
1511 wm8753_dai[0].codec = codec;
1512 wm8753_dai[1].codec = codec;
1515 static void wm8753_work(struct work_struct *work)
1517 struct snd_soc_codec *codec =
1518 container_of(work, struct snd_soc_codec, delayed_work.work);
1519 wm8753_set_bias_level(codec, codec->bias_level);
1522 static int wm8753_suspend(struct platform_device *pdev, pm_message_t state)
1524 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1525 struct snd_soc_codec *codec = socdev->codec;
1527 /* we only need to suspend if we are a valid card */
1531 wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
1535 static int wm8753_resume(struct platform_device *pdev)
1537 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1538 struct snd_soc_codec *codec = socdev->codec;
1541 u16 *cache = codec->reg_cache;
1543 /* we only need to resume if we are a valid card */
1547 /* Sync reg_cache with the hardware */
1548 for (i = 0; i < ARRAY_SIZE(wm8753_reg); i++) {
1549 if (i + 1 == WM8753_RESET)
1551 data[0] = ((i + 1) << 1) | ((cache[i] >> 8) & 0x0001);
1552 data[1] = cache[i] & 0x00ff;
1553 codec->hw_write(codec->control_data, data, 2);
1556 wm8753_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1558 /* charge wm8753 caps */
1559 if (codec->suspend_bias_level == SND_SOC_BIAS_ON) {
1560 wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
1561 codec->bias_level = SND_SOC_BIAS_ON;
1562 schedule_delayed_work(&codec->delayed_work,
1563 msecs_to_jiffies(caps_charge));
1570 * initialise the WM8753 driver
1571 * register the mixer and dsp interfaces with the kernel
1573 static int wm8753_init(struct snd_soc_device *socdev)
1575 struct snd_soc_codec *codec = socdev->codec;
1578 codec->name = "WM8753";
1579 codec->owner = THIS_MODULE;
1580 codec->read = wm8753_read_reg_cache;
1581 codec->write = wm8753_write;
1582 codec->set_bias_level = wm8753_set_bias_level;
1583 codec->dai = wm8753_dai;
1585 codec->reg_cache_size = ARRAY_SIZE(wm8753_reg);
1586 codec->reg_cache = kmemdup(wm8753_reg, sizeof(wm8753_reg), GFP_KERNEL);
1588 if (codec->reg_cache == NULL)
1591 wm8753_set_dai_mode(codec, 0);
1593 wm8753_reset(codec);
1596 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
1598 printk(KERN_ERR "wm8753: failed to create pcms\n");
1602 /* charge output caps */
1603 wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
1604 codec->bias_level = SND_SOC_BIAS_STANDBY;
1605 schedule_delayed_work(&codec->delayed_work,
1606 msecs_to_jiffies(caps_charge));
1608 /* set the update bits */
1609 reg = wm8753_read_reg_cache(codec, WM8753_LDAC);
1610 wm8753_write(codec, WM8753_LDAC, reg | 0x0100);
1611 reg = wm8753_read_reg_cache(codec, WM8753_RDAC);
1612 wm8753_write(codec, WM8753_RDAC, reg | 0x0100);
1613 reg = wm8753_read_reg_cache(codec, WM8753_LADC);
1614 wm8753_write(codec, WM8753_LADC, reg | 0x0100);
1615 reg = wm8753_read_reg_cache(codec, WM8753_RADC);
1616 wm8753_write(codec, WM8753_RADC, reg | 0x0100);
1617 reg = wm8753_read_reg_cache(codec, WM8753_LOUT1V);
1618 wm8753_write(codec, WM8753_LOUT1V, reg | 0x0100);
1619 reg = wm8753_read_reg_cache(codec, WM8753_ROUT1V);
1620 wm8753_write(codec, WM8753_ROUT1V, reg | 0x0100);
1621 reg = wm8753_read_reg_cache(codec, WM8753_LOUT2V);
1622 wm8753_write(codec, WM8753_LOUT2V, reg | 0x0100);
1623 reg = wm8753_read_reg_cache(codec, WM8753_ROUT2V);
1624 wm8753_write(codec, WM8753_ROUT2V, reg | 0x0100);
1625 reg = wm8753_read_reg_cache(codec, WM8753_LINVOL);
1626 wm8753_write(codec, WM8753_LINVOL, reg | 0x0100);
1627 reg = wm8753_read_reg_cache(codec, WM8753_RINVOL);
1628 wm8753_write(codec, WM8753_RINVOL, reg | 0x0100);
1630 wm8753_add_controls(codec);
1631 wm8753_add_widgets(codec);
1632 ret = snd_soc_register_card(socdev);
1634 printk(KERN_ERR "wm8753: failed to register card\n");
1641 snd_soc_free_pcms(socdev);
1642 snd_soc_dapm_free(socdev);
1644 kfree(codec->reg_cache);
1648 /* If the i2c layer weren't so broken, we could pass this kind of data
1650 static struct snd_soc_device *wm8753_socdev;
1652 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1655 * WM8753 2 wire address is determined by GPIO5
1656 * state during powerup.
1660 static unsigned short normal_i2c[] = { 0, I2C_CLIENT_END };
1662 /* Magic definition of all other variables and things */
1665 static struct i2c_driver wm8753_i2c_driver;
1666 static struct i2c_client client_template;
1668 static int wm8753_codec_probe(struct i2c_adapter *adap, int addr, int kind)
1670 struct snd_soc_device *socdev = wm8753_socdev;
1671 struct wm8753_setup_data *setup = socdev->codec_data;
1672 struct snd_soc_codec *codec = socdev->codec;
1673 struct i2c_client *i2c;
1676 if (addr != setup->i2c_address)
1679 client_template.adapter = adap;
1680 client_template.addr = addr;
1682 i2c = kmemdup(&client_template, sizeof(client_template), GFP_KERNEL);
1687 i2c_set_clientdata(i2c, codec);
1688 codec->control_data = i2c;
1690 ret = i2c_attach_client(i2c);
1692 err("failed to attach codec at addr %x\n", addr);
1696 ret = wm8753_init(socdev);
1698 err("failed to initialise WM8753\n");
1710 static int wm8753_i2c_detach(struct i2c_client *client)
1712 struct snd_soc_codec *codec = i2c_get_clientdata(client);
1713 i2c_detach_client(client);
1714 kfree(codec->reg_cache);
1719 static int wm8753_i2c_attach(struct i2c_adapter *adap)
1721 return i2c_probe(adap, &addr_data, wm8753_codec_probe);
1724 /* corgi i2c codec control layer */
1725 static struct i2c_driver wm8753_i2c_driver = {
1727 .name = "WM8753 I2C Codec",
1728 .owner = THIS_MODULE,
1730 .id = I2C_DRIVERID_WM8753,
1731 .attach_adapter = wm8753_i2c_attach,
1732 .detach_client = wm8753_i2c_detach,
1736 static struct i2c_client client_template = {
1738 .driver = &wm8753_i2c_driver,
1742 static int wm8753_probe(struct platform_device *pdev)
1744 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1745 struct wm8753_setup_data *setup;
1746 struct snd_soc_codec *codec;
1747 struct wm8753_priv *wm8753;
1750 info("WM8753 Audio Codec %s", WM8753_VERSION);
1752 setup = socdev->codec_data;
1753 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
1757 wm8753 = kzalloc(sizeof(struct wm8753_priv), GFP_KERNEL);
1758 if (wm8753 == NULL) {
1763 codec->private_data = wm8753;
1764 socdev->codec = codec;
1765 mutex_init(&codec->mutex);
1766 INIT_LIST_HEAD(&codec->dapm_widgets);
1767 INIT_LIST_HEAD(&codec->dapm_paths);
1768 wm8753_socdev = socdev;
1769 INIT_DELAYED_WORK(&codec->delayed_work, wm8753_work);
1771 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1772 if (setup->i2c_address) {
1773 normal_i2c[0] = setup->i2c_address;
1774 codec->hw_write = (hw_write_t)i2c_master_send;
1775 ret = i2c_add_driver(&wm8753_i2c_driver);
1777 printk(KERN_ERR "can't add i2c driver");
1780 /* Add other interfaces here */
1786 * This function forces any delayed work to be queued and run.
1788 static int run_delayed_work(struct delayed_work *dwork)
1792 /* cancel any work waiting to be queued. */
1793 ret = cancel_delayed_work(dwork);
1795 /* if there was any work waiting then we run it now and
1796 * wait for it's completion */
1798 schedule_delayed_work(dwork, 0);
1799 flush_scheduled_work();
1804 /* power down chip */
1805 static int wm8753_remove(struct platform_device *pdev)
1807 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1808 struct snd_soc_codec *codec = socdev->codec;
1810 if (codec->control_data)
1811 wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
1812 run_delayed_work(&codec->delayed_work);
1813 snd_soc_free_pcms(socdev);
1814 snd_soc_dapm_free(socdev);
1815 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1816 i2c_del_driver(&wm8753_i2c_driver);
1818 kfree(codec->private_data);
1824 struct snd_soc_codec_device soc_codec_dev_wm8753 = {
1825 .probe = wm8753_probe,
1826 .remove = wm8753_remove,
1827 .suspend = wm8753_suspend,
1828 .resume = wm8753_resume,
1830 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8753);
1832 MODULE_DESCRIPTION("ASoC WM8753 driver");
1833 MODULE_AUTHOR("Liam Girdwood");
1834 MODULE_LICENSE("GPL");