projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6-block.git] / sound / soc / codecs / wm8753.c
CommitLineData
1f53aee0
LG		 1/*
2 * wm8753.c -- WM8753 ALSA Soc Audio driver
3 *
4 * Copyright 2003 Wolfson Microelectronics PLC.
5 * Author: Liam Girdwood
6 * liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
7 *
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.
12 *
13 * Notes:
14 * The WM8753 is a low power, high quality stereo codec with integrated PCM
15 * codec designed for portable digital telephony applications.
16 *
17 * Dual DAI:-
18 *
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
21 * voice.
22 *
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
26 * normal alsa manner.
27 *
28 * Fast DAI switching:-
29 *
30 * The driver can now fast switch between the DAI configurations via a
31 * an alsa kcontrol. This allows the PCM to remain open.
32 *
33 */
34
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>
41#include <linux/pm.h>
42#include <linux/i2c.h>
43#include <linux/platform_device.h>
1f53aee0
LG		 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>
2d6a4ac9 50#include <sound/tlv.h>
1f53aee0
LG		 51#include <asm/div64.h>
52
53#include "wm8753.h"
54
55#define AUDIO_NAME "wm8753"
56#define WM8753_VERSION "0.16"
57
58/*
59 * Debug
60 */
61
62#define WM8753_DEBUG 0
63
64#ifdef WM8753_DEBUG
65#define dbg(format, arg...) \
66 printk(KERN_DEBUG AUDIO_NAME ": " format "\n" , ## arg)
67#else
68#define dbg(format, arg...) do {} while (0)
69#endif
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)
76
77static int caps_charge = 2000;
78module_param(caps_charge, int, 0);
79MODULE_PARM_DESC(caps_charge, "WM8753 cap charge time (msecs)");
80
81static void wm8753_set_dai_mode(struct snd_soc_codec *codec,
82 unsigned int mode);
83
84/* codec private data */
85struct wm8753_priv {
86 unsigned int sysclk;
87 unsigned int pcmclk;
88};
89
90/*
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.
94 */
95static 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,
111 0x0000, 0x0000
112};
113
114/*
115 * read wm8753 register cache
116 */
117static inline unsigned int wm8753_read_reg_cache(struct snd_soc_codec *codec,
118 unsigned int reg)
119{
120 u16 *cache = codec->reg_cache;
121 if (reg < 1 || reg > (ARRAY_SIZE(wm8753_reg) + 1))
122 return -1;
123 return cache[reg - 1];
124}
125
126/*
127 * write wm8753 register cache
128 */
129static inline void wm8753_write_reg_cache(struct snd_soc_codec *codec,
130 unsigned int reg, unsigned int value)
131{
132 u16 *cache = codec->reg_cache;
133 if (reg < 1 || reg > 0x3f)
134 return;
135 cache[reg - 1] = value;
136}
137
138/*
139 * write to the WM8753 register space
140 */
141static int wm8753_write(struct snd_soc_codec *codec, unsigned int reg,
142 unsigned int value)
143{
144 u8 data[2];
145
146 /* data is
147 * D15..D9 WM8753 register offset
148 * D8...D0 register data
149 */
150 data[0] = (reg << 1) | ((value >> 8) & 0x0001);
151 data[1] = value & 0x00ff;
152
60fc684a 153 wm8753_write_reg_cache(codec, reg, value);
1f53aee0
LG		 154 if (codec->hw_write(codec->control_data, data, 2) == 2)
155 return 0;
156 else
157 return -EIO;
158}
159
160#define wm8753_reset(c) wm8753_write(c, WM8753_RESET, 0)
161
162/*
163 * WM8753 Controls
164 */
165static const char *wm8753_base[] = {"Linear Control", "Adaptive Boost"};
166static const char *wm8753_base_filter[] =
167 {"130Hz @ 48kHz", "200Hz @ 48kHz", "100Hz @ 16kHz", "400Hz @ 48kHz",
168 "100Hz @ 8kHz", "200Hz @ 8kHz"};
169static const char *wm8753_treble[] = {"8kHz", "4kHz"};
170static const char *wm8753_alc_func[] = {"Off", "Right", "Left", "Stereo"};
171static const char *wm8753_ng_type[] = {"Constant PGA Gain", "Mute ADC Output"};
172static const char *wm8753_3d_func[] = {"Capture", "Playback"};
173static const char *wm8753_3d_uc[] = {"2.2kHz", "1.5kHz"};
174static const char *wm8753_3d_lc[] = {"200Hz", "500Hz"};
175static const char *wm8753_deemp[] = {"None", "32kHz", "44.1kHz", "48kHz"};
176static const char *wm8753_mono_mix[] = {"Stereo", "Left", "Right", "Mono"};
177static const char *wm8753_dac_phase[] = {"Non Inverted", "Inverted"};
178static const char *wm8753_line_mix[] = {"Line 1 + 2", "Line 1 - 2",
179 "Line 1", "Line 2"};
180static const char *wm8753_mono_mux[] = {"Line Mix", "Rx Mix"};
181static const char *wm8753_right_mux[] = {"Line 2", "Rx Mix"};
182static const char *wm8753_left_mux[] = {"Line 1", "Rx Mix"};
183static const char *wm8753_rxmsel[] = {"RXP - RXN", "RXP + RXN", "RXP", "RXN"};
184static const char *wm8753_sidetone_mux[] = {"Left PGA", "Mic 1", "Mic 2",
185 "Right PGA"};
186static const char *wm8753_mono2_src[] = {"Inverted Mono 1", "Left", "Right",
187 "Left + Right"};
188static const char *wm8753_out3[] = {"VREF", "ROUT2", "Left + Right"};
189static const char *wm8753_out4[] = {"VREF", "Capture ST", "LOUT2"};
190static const char *wm8753_radcsel[] = {"PGA", "Line or RXP-RXN", "Sidetone"};
191static const char *wm8753_ladcsel[] = {"PGA", "Line or RXP-RXN", "Line"};
192static const char *wm8753_mono_adc[] = {"Stereo", "Analogue Mix Left",
193 "Analogue Mix Right", "Digital Mono Mix"};
194static const char *wm8753_adc_hp[] = {"3.4Hz @ 48kHz", "82Hz @ 16k",
195 "82Hz @ 8kHz", "170Hz @ 8kHz"};
196static const char *wm8753_adc_filter[] = {"HiFi", "Voice"};
197static const char *wm8753_mic_sel[] = {"Mic 1", "Mic 2", "Mic 3"};
198static const char *wm8753_dai_mode[] = {"DAI 0", "DAI 1", "DAI 2", "DAI 3"};
199static const char *wm8753_dat_sel[] = {"Stereo", "Left ADC", "Right ADC",
200 "Channel Swap"};
ae092c9e 201static const char *wm8753_rout2_phase[] = {"Non Inverted", "Inverted"};
1f53aee0
LG		 202
203static const struct soc_enum wm8753_enum[] = {
204SOC_ENUM_SINGLE(WM8753_BASS, 7, 2, wm8753_base),
205SOC_ENUM_SINGLE(WM8753_BASS, 4, 6, wm8753_base_filter),
206SOC_ENUM_SINGLE(WM8753_TREBLE, 6, 2, wm8753_treble),
207SOC_ENUM_SINGLE(WM8753_ALC1, 7, 4, wm8753_alc_func),
208SOC_ENUM_SINGLE(WM8753_NGATE, 1, 2, wm8753_ng_type),
209SOC_ENUM_SINGLE(WM8753_3D, 7, 2, wm8753_3d_func),
210SOC_ENUM_SINGLE(WM8753_3D, 6, 2, wm8753_3d_uc),
211SOC_ENUM_SINGLE(WM8753_3D, 5, 2, wm8753_3d_lc),
212SOC_ENUM_SINGLE(WM8753_DAC, 1, 4, wm8753_deemp),
213SOC_ENUM_SINGLE(WM8753_DAC, 4, 4, wm8753_mono_mix),
214SOC_ENUM_SINGLE(WM8753_DAC, 6, 2, wm8753_dac_phase),
215SOC_ENUM_SINGLE(WM8753_INCTL1, 3, 4, wm8753_line_mix),
216SOC_ENUM_SINGLE(WM8753_INCTL1, 2, 2, wm8753_mono_mux),
217SOC_ENUM_SINGLE(WM8753_INCTL1, 1, 2, wm8753_right_mux),
218SOC_ENUM_SINGLE(WM8753_INCTL1, 0, 2, wm8753_left_mux),
219SOC_ENUM_SINGLE(WM8753_INCTL2, 6, 4, wm8753_rxmsel),
220SOC_ENUM_SINGLE(WM8753_INCTL2, 4, 4, wm8753_sidetone_mux),
221SOC_ENUM_SINGLE(WM8753_OUTCTL, 7, 4, wm8753_mono2_src),
222SOC_ENUM_SINGLE(WM8753_OUTCTL, 0, 3, wm8753_out3),
223SOC_ENUM_SINGLE(WM8753_ADCTL2, 7, 3, wm8753_out4),
224SOC_ENUM_SINGLE(WM8753_ADCIN, 2, 3, wm8753_radcsel),
225SOC_ENUM_SINGLE(WM8753_ADCIN, 0, 3, wm8753_ladcsel),
226SOC_ENUM_SINGLE(WM8753_ADCIN, 4, 4, wm8753_mono_adc),
227SOC_ENUM_SINGLE(WM8753_ADC, 2, 4, wm8753_adc_hp),
228SOC_ENUM_SINGLE(WM8753_ADC, 4, 2, wm8753_adc_filter),
229SOC_ENUM_SINGLE(WM8753_MICBIAS, 6, 3, wm8753_mic_sel),
230SOC_ENUM_SINGLE(WM8753_IOCTL, 2, 4, wm8753_dai_mode),
231SOC_ENUM_SINGLE(WM8753_ADC, 7, 4, wm8753_dat_sel),
ae092c9e 232SOC_ENUM_SINGLE(WM8753_OUTCTL, 2, 2, wm8753_rout2_phase),
1f53aee0
LG		 233};
234
235
236static int wm8753_get_dai(struct snd_kcontrol *kcontrol,
237 struct snd_ctl_elem_value *ucontrol)
238{
239 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
240 int mode = wm8753_read_reg_cache(codec, WM8753_IOCTL);
241
242 ucontrol->value.integer.value[0] = (mode & 0xc) >> 2;
243 return 0;
244}
245
246static int wm8753_set_dai(struct snd_kcontrol *kcontrol,
247 struct snd_ctl_elem_value *ucontrol)
248{
249 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
250 int mode = wm8753_read_reg_cache(codec, WM8753_IOCTL);
251
60fc684a 252 if (((mode & 0xc) >> 2) == ucontrol->value.integer.value[0])
1f53aee0
LG		 253 return 0;
254
255 mode &= 0xfff3;
256 mode |= (ucontrol->value.integer.value[0] << 2);
257
258 wm8753_write(codec, WM8753_IOCTL, mode);
259 wm8753_set_dai_mode(codec, ucontrol->value.integer.value[0]);
260 return 1;
261}
262
2d6a4ac9
LG		 263static const DECLARE_TLV_DB_LINEAR(rec_mix_tlv, -1500, 600);
264
1f53aee0
LG		 265static const struct snd_kcontrol_new wm8753_snd_controls[] = {
266SOC_DOUBLE_R("PCM Volume", WM8753_LDAC, WM8753_RDAC, 0, 255, 0),
267
268SOC_DOUBLE_R("ADC Capture Volume", WM8753_LADC, WM8753_RADC, 0, 255, 0),
269
270SOC_DOUBLE_R("Headphone Playback Volume", WM8753_LOUT1V, WM8753_ROUT1V, 0, 127, 0),
271SOC_DOUBLE_R("Speaker Playback Volume", WM8753_LOUT2V, WM8753_ROUT2V, 0, 127, 0),
272
273SOC_SINGLE("Mono Playback Volume", WM8753_MOUTV, 0, 127, 0),
274
275SOC_DOUBLE_R("Bypass Playback Volume", WM8753_LOUTM1, WM8753_ROUTM1, 4, 7, 1),
276SOC_DOUBLE_R("Sidetone Playback Volume", WM8753_LOUTM2, WM8753_ROUTM2, 4, 7, 1),
277SOC_DOUBLE_R("Voice Playback Volume", WM8753_LOUTM2, WM8753_ROUTM2, 0, 7, 1),
278
279SOC_DOUBLE_R("Headphone Playback ZC Switch", WM8753_LOUT1V, WM8753_ROUT1V, 7, 1, 0),
280SOC_DOUBLE_R("Speaker Playback ZC Switch", WM8753_LOUT2V, WM8753_ROUT2V, 7, 1, 0),
281
282SOC_SINGLE("Mono Bypass Playback Volume", WM8753_MOUTM1, 4, 7, 1),
283SOC_SINGLE("Mono Sidetone Playback Volume", WM8753_MOUTM2, 4, 7, 1),
10264608 284SOC_SINGLE("Mono Voice Playback Volume", WM8753_MOUTM2, 0, 7, 1),
1f53aee0
LG		 285SOC_SINGLE("Mono Playback ZC Switch", WM8753_MOUTV, 7, 1, 0),
286
287SOC_ENUM("Bass Boost", wm8753_enum[0]),
288SOC_ENUM("Bass Filter", wm8753_enum[1]),
289SOC_SINGLE("Bass Volume", WM8753_BASS, 0, 15, 1),
290
291SOC_SINGLE("Treble Volume", WM8753_TREBLE, 0, 15, 1),
292SOC_ENUM("Treble Cut-off", wm8753_enum[2]),
293
2d6a4ac9
LG		 294SOC_DOUBLE_TLV("Sidetone Capture Volume", WM8753_RECMIX1, 0, 4, 7, 1, rec_mix_tlv),
295SOC_SINGLE_TLV("Voice Sidetone Capture Volume", WM8753_RECMIX2, 0, 7, 1, rec_mix_tlv),
1f53aee0
LG		 296
297SOC_DOUBLE_R("Capture Volume", WM8753_LINVOL, WM8753_RINVOL, 0, 63, 0),
298SOC_DOUBLE_R("Capture ZC Switch", WM8753_LINVOL, WM8753_RINVOL, 6, 1, 0),
299SOC_DOUBLE_R("Capture Switch", WM8753_LINVOL, WM8753_RINVOL, 7, 1, 1),
300
301SOC_ENUM("Capture Filter Select", wm8753_enum[23]),
302SOC_ENUM("Capture Filter Cut-off", wm8753_enum[24]),
303SOC_SINGLE("Capture Filter Switch", WM8753_ADC, 0, 1, 1),
304
305SOC_SINGLE("ALC Capture Target Volume", WM8753_ALC1, 0, 7, 0),
306SOC_SINGLE("ALC Capture Max Volume", WM8753_ALC1, 4, 7, 0),
307SOC_ENUM("ALC Capture Function", wm8753_enum[3]),
308SOC_SINGLE("ALC Capture ZC Switch", WM8753_ALC2, 8, 1, 0),
309SOC_SINGLE("ALC Capture Hold Time", WM8753_ALC2, 0, 15, 1),
310SOC_SINGLE("ALC Capture Decay Time", WM8753_ALC3, 4, 15, 1),
311SOC_SINGLE("ALC Capture Attack Time", WM8753_ALC3, 0, 15, 0),
312SOC_SINGLE("ALC Capture NG Threshold", WM8753_NGATE, 3, 31, 0),
313SOC_ENUM("ALC Capture NG Type", wm8753_enum[4]),
314SOC_SINGLE("ALC Capture NG Switch", WM8753_NGATE, 0, 1, 0),
315
316SOC_ENUM("3D Function", wm8753_enum[5]),
317SOC_ENUM("3D Upper Cut-off", wm8753_enum[6]),
318SOC_ENUM("3D Lower Cut-off", wm8753_enum[7]),
319SOC_SINGLE("3D Volume", WM8753_3D, 1, 15, 0),
320SOC_SINGLE("3D Switch", WM8753_3D, 0, 1, 0),
321
322SOC_SINGLE("Capture 6dB Attenuate", WM8753_ADCTL1, 2, 1, 0),
323SOC_SINGLE("Playback 6dB Attenuate", WM8753_ADCTL1, 1, 1, 0),
324
325SOC_ENUM("De-emphasis", wm8753_enum[8]),
326SOC_ENUM("Playback Mono Mix", wm8753_enum[9]),
327SOC_ENUM("Playback Phase", wm8753_enum[10]),
328
329SOC_SINGLE("Mic2 Capture Volume", WM8753_INCTL1, 7, 3, 0),
330SOC_SINGLE("Mic1 Capture Volume", WM8753_INCTL1, 5, 3, 0),
331
332SOC_ENUM_EXT("DAI Mode", wm8753_enum[26], wm8753_get_dai, wm8753_set_dai),
333
334SOC_ENUM("ADC Data Select", wm8753_enum[27]),
ae092c9e 335SOC_ENUM("ROUT2 Phase", wm8753_enum[28]),
1f53aee0
LG		 336};
337
338/* add non dapm controls */
339static int wm8753_add_controls(struct snd_soc_codec *codec)
340{
341 int err, i;
342
343 for (i = 0; i < ARRAY_SIZE(wm8753_snd_controls); i++) {
344 err = snd_ctl_add(codec->card,
60fc684a
MB		 345 snd_soc_cnew(&wm8753_snd_controls[i],
346 codec, NULL));
1f53aee0
LG		 347 if (err < 0)
348 return err;
349 }
350 return 0;
351}
352
353/*
354 * _DAPM_ Controls
355 */
356
357/* Left Mixer */
358static const struct snd_kcontrol_new wm8753_left_mixer_controls[] = {
359SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_LOUTM2, 8, 1, 0),
360SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_LOUTM2, 7, 1, 0),
361SOC_DAPM_SINGLE("Left Playback Switch", WM8753_LOUTM1, 8, 1, 0),
362SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_LOUTM1, 7, 1, 0),
363};
364
365/* Right mixer */
366static const struct snd_kcontrol_new wm8753_right_mixer_controls[] = {
367SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_ROUTM2, 8, 1, 0),
368SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_ROUTM2, 7, 1, 0),
369SOC_DAPM_SINGLE("Right Playback Switch", WM8753_ROUTM1, 8, 1, 0),
370SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_ROUTM1, 7, 1, 0),
371};
372
373/* Mono mixer */
374static const struct snd_kcontrol_new wm8753_mono_mixer_controls[] = {
375SOC_DAPM_SINGLE("Left Playback Switch", WM8753_MOUTM1, 8, 1, 0),
376SOC_DAPM_SINGLE("Right Playback Switch", WM8753_MOUTM2, 8, 1, 0),
377SOC_DAPM_SINGLE("Voice Playback Switch", WM8753_MOUTM2, 3, 1, 0),
378SOC_DAPM_SINGLE("Sidetone Playback Switch", WM8753_MOUTM2, 7, 1, 0),
379SOC_DAPM_SINGLE("Bypass Playback Switch", WM8753_MOUTM1, 7, 1, 0),
380};
381
382/* Mono 2 Mux */
383static const struct snd_kcontrol_new wm8753_mono2_controls =
384SOC_DAPM_ENUM("Route", wm8753_enum[17]);
385
386/* Out 3 Mux */
387static const struct snd_kcontrol_new wm8753_out3_controls =
388SOC_DAPM_ENUM("Route", wm8753_enum[18]);
389
390/* Out 4 Mux */
391static const struct snd_kcontrol_new wm8753_out4_controls =
392SOC_DAPM_ENUM("Route", wm8753_enum[19]);
393
394/* ADC Mono Mix */
395static const struct snd_kcontrol_new wm8753_adc_mono_controls =
396SOC_DAPM_ENUM("Route", wm8753_enum[22]);
397
398/* Record mixer */
399static const struct snd_kcontrol_new wm8753_record_mixer_controls[] = {
400SOC_DAPM_SINGLE("Voice Capture Switch", WM8753_RECMIX2, 3, 1, 0),
401SOC_DAPM_SINGLE("Left Capture Switch", WM8753_RECMIX1, 3, 1, 0),
402SOC_DAPM_SINGLE("Right Capture Switch", WM8753_RECMIX1, 7, 1, 0),
403};
404
405/* Left ADC mux */
406static const struct snd_kcontrol_new wm8753_adc_left_controls =
407SOC_DAPM_ENUM("Route", wm8753_enum[21]);
408
409/* Right ADC mux */
410static const struct snd_kcontrol_new wm8753_adc_right_controls =
411SOC_DAPM_ENUM("Route", wm8753_enum[20]);
412
413/* MIC mux */
414static const struct snd_kcontrol_new wm8753_mic_mux_controls =
415SOC_DAPM_ENUM("Route", wm8753_enum[16]);
416
417/* ALC mixer */
418static const struct snd_kcontrol_new wm8753_alc_mixer_controls[] = {
419SOC_DAPM_SINGLE("Line Capture Switch", WM8753_INCTL2, 3, 1, 0),
420SOC_DAPM_SINGLE("Mic2 Capture Switch", WM8753_INCTL2, 2, 1, 0),
421SOC_DAPM_SINGLE("Mic1 Capture Switch", WM8753_INCTL2, 1, 1, 0),
422SOC_DAPM_SINGLE("Rx Capture Switch", WM8753_INCTL2, 0, 1, 0),
423};
424
425/* Left Line mux */
426static const struct snd_kcontrol_new wm8753_line_left_controls =
427SOC_DAPM_ENUM("Route", wm8753_enum[14]);
428
429/* Right Line mux */
430static const struct snd_kcontrol_new wm8753_line_right_controls =
431SOC_DAPM_ENUM("Route", wm8753_enum[13]);
432
433/* Mono Line mux */
434static const struct snd_kcontrol_new wm8753_line_mono_controls =
435SOC_DAPM_ENUM("Route", wm8753_enum[12]);
436
437/* Line mux and mixer */
438static const struct snd_kcontrol_new wm8753_line_mux_mix_controls =
439SOC_DAPM_ENUM("Route", wm8753_enum[11]);
440
441/* Rx mux and mixer */
442static const struct snd_kcontrol_new wm8753_rx_mux_mix_controls =
443SOC_DAPM_ENUM("Route", wm8753_enum[15]);
444
445/* Mic Selector Mux */
446static const struct snd_kcontrol_new wm8753_mic_sel_mux_controls =
447SOC_DAPM_ENUM("Route", wm8753_enum[25]);
448
449static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
450SND_SOC_DAPM_MICBIAS("Mic Bias", WM8753_PWR1, 5, 0),
451SND_SOC_DAPM_MIXER("Left Mixer", WM8753_PWR4, 0, 0,
452 &wm8753_left_mixer_controls[0], ARRAY_SIZE(wm8753_left_mixer_controls)),
453SND_SOC_DAPM_PGA("Left Out 1", WM8753_PWR3, 8, 0, NULL, 0),
454SND_SOC_DAPM_PGA("Left Out 2", WM8753_PWR3, 6, 0, NULL, 0),
455SND_SOC_DAPM_DAC("Left DAC", "Left HiFi Playback", WM8753_PWR1, 3, 0),
456SND_SOC_DAPM_OUTPUT("LOUT1"),
457SND_SOC_DAPM_OUTPUT("LOUT2"),
458SND_SOC_DAPM_MIXER("Right Mixer", WM8753_PWR4, 1, 0,
459 &wm8753_right_mixer_controls[0], ARRAY_SIZE(wm8753_right_mixer_controls)),
460SND_SOC_DAPM_PGA("Right Out 1", WM8753_PWR3, 7, 0, NULL, 0),
461SND_SOC_DAPM_PGA("Right Out 2", WM8753_PWR3, 5, 0, NULL, 0),
462SND_SOC_DAPM_DAC("Right DAC", "Right HiFi Playback", WM8753_PWR1, 2, 0),
463SND_SOC_DAPM_OUTPUT("ROUT1"),
464SND_SOC_DAPM_OUTPUT("ROUT2"),
465SND_SOC_DAPM_MIXER("Mono Mixer", WM8753_PWR4, 2, 0,
466 &wm8753_mono_mixer_controls[0], ARRAY_SIZE(wm8753_mono_mixer_controls)),
467SND_SOC_DAPM_PGA("Mono Out 1", WM8753_PWR3, 2, 0, NULL, 0),
468SND_SOC_DAPM_PGA("Mono Out 2", WM8753_PWR3, 1, 0, NULL, 0),
469SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", WM8753_PWR1, 4, 0),
470SND_SOC_DAPM_OUTPUT("MONO1"),
471SND_SOC_DAPM_MUX("Mono 2 Mux", SND_SOC_NOPM, 0, 0, &wm8753_mono2_controls),
472SND_SOC_DAPM_OUTPUT("MONO2"),
473SND_SOC_DAPM_MIXER("Out3 Left + Right", -1, 0, 0, NULL, 0),
474SND_SOC_DAPM_MUX("Out3 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out3_controls),
475SND_SOC_DAPM_PGA("Out 3", WM8753_PWR3, 4, 0, NULL, 0),
476SND_SOC_DAPM_OUTPUT("OUT3"),
477SND_SOC_DAPM_MUX("Out4 Mux", SND_SOC_NOPM, 0, 0, &wm8753_out4_controls),
478SND_SOC_DAPM_PGA("Out 4", WM8753_PWR3, 3, 0, NULL, 0),
479SND_SOC_DAPM_OUTPUT("OUT4"),
480SND_SOC_DAPM_MIXER("Playback Mixer", WM8753_PWR4, 3, 0,
481 &wm8753_record_mixer_controls[0],
482 ARRAY_SIZE(wm8753_record_mixer_controls)),
483SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8753_PWR2, 3, 0),
484SND_SOC_DAPM_ADC("Right ADC", "Right Capture", WM8753_PWR2, 2, 0),
485SND_SOC_DAPM_MUX("Capture Left Mixer", SND_SOC_NOPM, 0, 0,
486 &wm8753_adc_mono_controls),
487SND_SOC_DAPM_MUX("Capture Right Mixer", SND_SOC_NOPM, 0, 0,
488 &wm8753_adc_mono_controls),
489SND_SOC_DAPM_MUX("Capture Left Mux", SND_SOC_NOPM, 0, 0,
490 &wm8753_adc_left_controls),
491SND_SOC_DAPM_MUX("Capture Right Mux", SND_SOC_NOPM, 0, 0,
492 &wm8753_adc_right_controls),
493SND_SOC_DAPM_MUX("Mic Sidetone Mux", SND_SOC_NOPM, 0, 0,
494 &wm8753_mic_mux_controls),
495SND_SOC_DAPM_PGA("Left Capture Volume", WM8753_PWR2, 5, 0, NULL, 0),
496SND_SOC_DAPM_PGA("Right Capture Volume", WM8753_PWR2, 4, 0, NULL, 0),
497SND_SOC_DAPM_MIXER("ALC Mixer", WM8753_PWR2, 6, 0,
498 &wm8753_alc_mixer_controls[0], ARRAY_SIZE(wm8753_alc_mixer_controls)),
499SND_SOC_DAPM_MUX("Line Left Mux", SND_SOC_NOPM, 0, 0,
500 &wm8753_line_left_controls),
501SND_SOC_DAPM_MUX("Line Right Mux", SND_SOC_NOPM, 0, 0,
502 &wm8753_line_right_controls),
503SND_SOC_DAPM_MUX("Line Mono Mux", SND_SOC_NOPM, 0, 0,
504 &wm8753_line_mono_controls),
505SND_SOC_DAPM_MUX("Line Mixer", WM8753_PWR2, 0, 0,
506 &wm8753_line_mux_mix_controls),
507SND_SOC_DAPM_MUX("Rx Mixer", WM8753_PWR2, 1, 0,
508 &wm8753_rx_mux_mix_controls),
509SND_SOC_DAPM_PGA("Mic 1 Volume", WM8753_PWR2, 8, 0, NULL, 0),
510SND_SOC_DAPM_PGA("Mic 2 Volume", WM8753_PWR2, 7, 0, NULL, 0),
511SND_SOC_DAPM_MUX("Mic Selection Mux", SND_SOC_NOPM, 0, 0,
512 &wm8753_mic_sel_mux_controls),
513SND_SOC_DAPM_INPUT("LINE1"),
514SND_SOC_DAPM_INPUT("LINE2"),
515SND_SOC_DAPM_INPUT("RXP"),
516SND_SOC_DAPM_INPUT("RXN"),
517SND_SOC_DAPM_INPUT("ACIN"),
518SND_SOC_DAPM_OUTPUT("ACOP"),
519SND_SOC_DAPM_INPUT("MIC1N"),
520SND_SOC_DAPM_INPUT("MIC1"),
521SND_SOC_DAPM_INPUT("MIC2N"),
522SND_SOC_DAPM_INPUT("MIC2"),
523SND_SOC_DAPM_VMID("VREF"),
524};
525
526static const char *audio_map[][3] = {
527 /* left mixer */
528 {"Left Mixer", "Left Playback Switch", "Left DAC"},
529 {"Left Mixer", "Voice Playback Switch", "Voice DAC"},
530 {"Left Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
531 {"Left Mixer", "Bypass Playback Switch", "Line Left Mux"},
532
533 /* right mixer */
534 {"Right Mixer", "Right Playback Switch", "Right DAC"},
535 {"Right Mixer", "Voice Playback Switch", "Voice DAC"},
536 {"Right Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
537 {"Right Mixer", "Bypass Playback Switch", "Line Right Mux"},
538
539 /* mono mixer */
540 {"Mono Mixer", "Voice Playback Switch", "Voice DAC"},
541 {"Mono Mixer", "Left Playback Switch", "Left DAC"},
542 {"Mono Mixer", "Right Playback Switch", "Right DAC"},
543 {"Mono Mixer", "Sidetone Playback Switch", "Mic Sidetone Mux"},
544 {"Mono Mixer", "Bypass Playback Switch", "Line Mono Mux"},
545
546 /* left out */
547 {"Left Out 1", NULL, "Left Mixer"},
548 {"Left Out 2", NULL, "Left Mixer"},
549 {"LOUT1", NULL, "Left Out 1"},
550 {"LOUT2", NULL, "Left Out 2"},
551
552 /* right out */
553 {"Right Out 1", NULL, "Right Mixer"},
554 {"Right Out 2", NULL, "Right Mixer"},
555 {"ROUT1", NULL, "Right Out 1"},
556 {"ROUT2", NULL, "Right Out 2"},
557
558 /* mono 1 out */
559 {"Mono Out 1", NULL, "Mono Mixer"},
560 {"MONO1", NULL, "Mono Out 1"},
561
562 /* mono 2 out */
563 {"Mono 2 Mux", "Left + Right", "Out3 Left + Right"},
564 {"Mono 2 Mux", "Inverted Mono 1", "MONO1"},
565 {"Mono 2 Mux", "Left", "Left Mixer"},
566 {"Mono 2 Mux", "Right", "Right Mixer"},
567 {"Mono Out 2", NULL, "Mono 2 Mux"},
568 {"MONO2", NULL, "Mono Out 2"},
569
570 /* out 3 */
571 {"Out3 Left + Right", NULL, "Left Mixer"},
572 {"Out3 Left + Right", NULL, "Right Mixer"},
573 {"Out3 Mux", "VREF", "VREF"},
574 {"Out3 Mux", "Left + Right", "Out3 Left + Right"},
575 {"Out3 Mux", "ROUT2", "ROUT2"},
576 {"Out 3", NULL, "Out3 Mux"},
577 {"OUT3", NULL, "Out 3"},
578
579 /* out 4 */
580 {"Out4 Mux", "VREF", "VREF"},
581 {"Out4 Mux", "Capture ST", "Capture ST Mixer"},
582 {"Out4 Mux", "LOUT2", "LOUT2"},
583 {"Out 4", NULL, "Out4 Mux"},
584 {"OUT4", NULL, "Out 4"},
585
586 /* record mixer */
587 {"Playback Mixer", "Left Capture Switch", "Left Mixer"},
588 {"Playback Mixer", "Voice Capture Switch", "Mono Mixer"},
589 {"Playback Mixer", "Right Capture Switch", "Right Mixer"},
590
591 /* Mic/SideTone Mux */
592 {"Mic Sidetone Mux", "Left PGA", "Left Capture Volume"},
593 {"Mic Sidetone Mux", "Right PGA", "Right Capture Volume"},
594 {"Mic Sidetone Mux", "Mic 1", "Mic 1 Volume"},
595 {"Mic Sidetone Mux", "Mic 2", "Mic 2 Volume"},
596
597 /* Capture Left Mux */
598 {"Capture Left Mux", "PGA", "Left Capture Volume"},
599 {"Capture Left Mux", "Line or RXP-RXN", "Line Left Mux"},
600 {"Capture Left Mux", "Line", "LINE1"},
601
602 /* Capture Right Mux */
603 {"Capture Right Mux", "PGA", "Right Capture Volume"},
604 {"Capture Right Mux", "Line or RXP-RXN", "Line Right Mux"},
605 {"Capture Right Mux", "Sidetone", "Capture ST Mixer"},
606
607 /* Mono Capture mixer-mux */
608 {"Capture Right Mixer", "Stereo", "Capture Right Mux"},
609 {"Capture Left Mixer", "Analogue Mix Left", "Capture Left Mux"},
610 {"Capture Left Mixer", "Analogue Mix Left", "Capture Right Mux"},
611 {"Capture Right Mixer", "Analogue Mix Right", "Capture Left Mux"},
612 {"Capture Right Mixer", "Analogue Mix Right", "Capture Right Mux"},
613 {"Capture Left Mixer", "Digital Mono Mix", "Capture Left Mux"},
614 {"Capture Left Mixer", "Digital Mono Mix", "Capture Right Mux"},
615 {"Capture Right Mixer", "Digital Mono Mix", "Capture Left Mux"},
616 {"Capture Right Mixer", "Digital Mono Mix", "Capture Right Mux"},
617
618 /* ADC */
619 {"Left ADC", NULL, "Capture Left Mixer"},
620 {"Right ADC", NULL, "Capture Right Mixer"},
621
622 /* Left Capture Volume */
623 {"Left Capture Volume", NULL, "ACIN"},
624
625 /* Right Capture Volume */
626 {"Right Capture Volume", NULL, "Mic 2 Volume"},
627
628 /* ALC Mixer */
629 {"ALC Mixer", "Line Capture Switch", "Line Mixer"},
630 {"ALC Mixer", "Mic2 Capture Switch", "Mic 2 Volume"},
631 {"ALC Mixer", "Mic1 Capture Switch", "Mic 1 Volume"},
632 {"ALC Mixer", "Rx Capture Switch", "Rx Mixer"},
633
634 /* Line Left Mux */
635 {"Line Left Mux", "Line 1", "LINE1"},
636 {"Line Left Mux", "Rx Mix", "Rx Mixer"},
637
638 /* Line Right Mux */
639 {"Line Right Mux", "Line 2", "LINE2"},
640 {"Line Right Mux", "Rx Mix", "Rx Mixer"},
641
642 /* Line Mono Mux */
643 {"Line Mono Mux", "Line Mix", "Line Mixer"},
644 {"Line Mono Mux", "Rx Mix", "Rx Mixer"},
645
646 /* Line Mixer/Mux */
647 {"Line Mixer", "Line 1 + 2", "LINE1"},
648 {"Line Mixer", "Line 1 - 2", "LINE1"},
649 {"Line Mixer", "Line 1 + 2", "LINE2"},
650 {"Line Mixer", "Line 1 - 2", "LINE2"},
651 {"Line Mixer", "Line 1", "LINE1"},
652 {"Line Mixer", "Line 2", "LINE2"},
653
654 /* Rx Mixer/Mux */
655 {"Rx Mixer", "RXP - RXN", "RXP"},
656 {"Rx Mixer", "RXP + RXN", "RXP"},
657 {"Rx Mixer", "RXP - RXN", "RXN"},
658 {"Rx Mixer", "RXP + RXN", "RXN"},
659 {"Rx Mixer", "RXP", "RXP"},
660 {"Rx Mixer", "RXN", "RXN"},
661
662 /* Mic 1 Volume */
663 {"Mic 1 Volume", NULL, "MIC1N"},
664 {"Mic 1 Volume", NULL, "Mic Selection Mux"},
665
666 /* Mic 2 Volume */
667 {"Mic 2 Volume", NULL, "MIC2N"},
668 {"Mic 2 Volume", NULL, "MIC2"},
669
670 /* Mic Selector Mux */
671 {"Mic Selection Mux", "Mic 1", "MIC1"},
672 {"Mic Selection Mux", "Mic 2", "MIC2N"},
673 {"Mic Selection Mux", "Mic 3", "MIC2"},
674
675 /* ACOP */
676 {"ACOP", NULL, "ALC Mixer"},
677
678 /* terminator */
679 {NULL, NULL, NULL},
680};
681
682static int wm8753_add_widgets(struct snd_soc_codec *codec)
683{
684 int i;
685
686 for (i = 0; i < ARRAY_SIZE(wm8753_dapm_widgets); i++)
687 snd_soc_dapm_new_control(codec, &wm8753_dapm_widgets[i]);
688
689 /* set up the WM8753 audio map */
690 for (i = 0; audio_map[i][0] != NULL; i++) {
691 snd_soc_dapm_connect_input(codec, audio_map[i][0],
692 audio_map[i][1], audio_map[i][2]);
693 }
694
695 snd_soc_dapm_new_widgets(codec);
696 return 0;
697}
698
699/* PLL divisors */
700struct _pll_div {
701 u32 div2:1;
702 u32 n:4;
703 u32 k:24;
704};
705
706/* The size in bits of the pll divide multiplied by 10
707 * to allow rounding later */
708#define FIXED_PLL_SIZE ((1 << 22) * 10)
709
710static void pll_factors(struct _pll_div *pll_div, unsigned int target,
711 unsigned int source)
712{
713 u64 Kpart;
714 unsigned int K, Ndiv, Nmod;
715
716 Ndiv = target / source;
717 if (Ndiv < 6) {
718 source >>= 1;
719 pll_div->div2 = 1;
720 Ndiv = target / source;
721 } else
722 pll_div->div2 = 0;
723
724 if ((Ndiv < 6) || (Ndiv > 12))
725 printk(KERN_WARNING
60fc684a 726 "wm8753: unsupported N = %d\n", Ndiv);
1f53aee0
LG		 727
728 pll_div->n = Ndiv;
729 Nmod = target % source;
730 Kpart = FIXED_PLL_SIZE * (long long)Nmod;
731
732 do_div(Kpart, source);
733
734 K = Kpart & 0xFFFFFFFF;
735
736 /* Check if we need to round */
737 if ((K % 10) >= 5)
738 K += 5;
739
740 /* Move down to proper range now rounding is done */
741 K /= 10;
742
743 pll_div->k = K;
744}
745
746static int wm8753_set_dai_pll(struct snd_soc_codec_dai *codec_dai,
747 int pll_id, unsigned int freq_in, unsigned int freq_out)
748{
749 u16 reg, enable;
750 int offset;
751 struct snd_soc_codec *codec = codec_dai->codec;
752
753 if (pll_id < WM8753_PLL1 || pll_id > WM8753_PLL2)
754 return -ENODEV;
755
756 if (pll_id == WM8753_PLL1) {
757 offset = 0;
758 enable = 0x10;
759 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xffef;
760 } else {
761 offset = 4;
762 enable = 0x8;
763 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfff7;
764 }
765
766 if (!freq_in || !freq_out) {
767 /* disable PLL */
768 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0026);
769 wm8753_write(codec, WM8753_CLOCK, reg);
770 return 0;
771 } else {
772 u16 value = 0;
773 struct _pll_div pll_div;
774
775 pll_factors(&pll_div, freq_out * 8, freq_in);
776
777 /* set up N and K PLL divisor ratios */
778 /* bits 8:5 = PLL_N, bits 3:0 = PLL_K[21:18] */
779 value = (pll_div.n << 5) + ((pll_div.k & 0x3c0000) >> 18);
780 wm8753_write(codec, WM8753_PLL1CTL2 + offset, value);
781
782 /* bits 8:0 = PLL_K[17:9] */
783 value = (pll_div.k & 0x03fe00) >> 9;
784 wm8753_write(codec, WM8753_PLL1CTL3 + offset, value);
785
786 /* bits 8:0 = PLL_K[8:0] */
787 value = pll_div.k & 0x0001ff;
788 wm8753_write(codec, WM8753_PLL1CTL4 + offset, value);
789
790 /* set PLL as input and enable */
791 wm8753_write(codec, WM8753_PLL1CTL1 + offset, 0x0027 |
792 (pll_div.div2 << 3));
793 wm8753_write(codec, WM8753_CLOCK, reg | enable);
794 }
795 return 0;
796}
797
798struct _coeff_div {
799 u32 mclk;
800 u32 rate;
801 u8 sr:5;
802 u8 usb:1;
803};
804
805/* codec hifi mclk (after PLL) clock divider coefficients */
806static const struct _coeff_div coeff_div[] = {
807 /* 8k */
808 {12288000, 8000, 0x6, 0x0},
809 {11289600, 8000, 0x16, 0x0},
810 {18432000, 8000, 0x7, 0x0},
811 {16934400, 8000, 0x17, 0x0},
812 {12000000, 8000, 0x6, 0x1},
813
814 /* 11.025k */
815 {11289600, 11025, 0x18, 0x0},
816 {16934400, 11025, 0x19, 0x0},
817 {12000000, 11025, 0x19, 0x1},
818
819 /* 16k */
820 {12288000, 16000, 0xa, 0x0},
821 {18432000, 16000, 0xb, 0x0},
822 {12000000, 16000, 0xa, 0x1},
823
824 /* 22.05k */
825 {11289600, 22050, 0x1a, 0x0},
826 {16934400, 22050, 0x1b, 0x0},
827 {12000000, 22050, 0x1b, 0x1},
828
829 /* 32k */
830 {12288000, 32000, 0xc, 0x0},
831 {18432000, 32000, 0xd, 0x0},
832 {12000000, 32000, 0xa, 0x1},
833
834 /* 44.1k */
835 {11289600, 44100, 0x10, 0x0},
836 {16934400, 44100, 0x11, 0x0},
837 {12000000, 44100, 0x11, 0x1},
838
839 /* 48k */
840 {12288000, 48000, 0x0, 0x0},
841 {18432000, 48000, 0x1, 0x0},
842 {12000000, 48000, 0x0, 0x1},
843
844 /* 88.2k */
845 {11289600, 88200, 0x1e, 0x0},
846 {16934400, 88200, 0x1f, 0x0},
847 {12000000, 88200, 0x1f, 0x1},
848
849 /* 96k */
850 {12288000, 96000, 0xe, 0x0},
851 {18432000, 96000, 0xf, 0x0},
852 {12000000, 96000, 0xe, 0x1},
853};
854
855static int get_coeff(int mclk, int rate)
856{
857 int i;
858
859 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
860 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
861 return i;
862 }
863 return -EINVAL;
864}
865
866/*
867 * Clock after PLL and dividers
868 */
869static int wm8753_set_dai_sysclk(struct snd_soc_codec_dai *codec_dai,
870 int clk_id, unsigned int freq, int dir)
871{
872 struct snd_soc_codec *codec = codec_dai->codec;
873 struct wm8753_priv *wm8753 = codec->private_data;
874
875 switch (freq) {
876 case 11289600:
877 case 12000000:
878 case 12288000:
879 case 16934400:
880 case 18432000:
881 if (clk_id == WM8753_MCLK) {
882 wm8753->sysclk = freq;
883 return 0;
884 } else if (clk_id == WM8753_PCMCLK) {
885 wm8753->pcmclk = freq;
886 return 0;
887 }
888 break;
889 }
890 return -EINVAL;
891}
892
893/*
894 * Set's ADC and Voice DAC format.
895 */
896static int wm8753_vdac_adc_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
897 unsigned int fmt)
898{
899 struct snd_soc_codec *codec = codec_dai->codec;
900 u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01ec;
901
902 /* interface format */
903 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
904 case SND_SOC_DAIFMT_I2S:
905 voice |= 0x0002;
906 break;
907 case SND_SOC_DAIFMT_RIGHT_J:
908 break;
909 case SND_SOC_DAIFMT_LEFT_J:
910 voice |= 0x0001;
911 break;
912 case SND_SOC_DAIFMT_DSP_A:
913 voice |= 0x0003;
914 break;
915 case SND_SOC_DAIFMT_DSP_B:
916 voice |= 0x0013;
917 break;
918 default:
919 return -EINVAL;
920 }
921
922 wm8753_write(codec, WM8753_PCM, voice);
923 return 0;
924}
925
926/*
927 * Set PCM DAI bit size and sample rate.
928 */
929static int wm8753_pcm_hw_params(struct snd_pcm_substream *substream,
930 struct snd_pcm_hw_params *params)
931{
932 struct snd_soc_pcm_runtime *rtd = substream->private_data;
933 struct snd_soc_device *socdev = rtd->socdev;
934 struct snd_soc_codec *codec = socdev->codec;
935 struct wm8753_priv *wm8753 = codec->private_data;
936 u16 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x01f3;
937 u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x017f;
938
939 /* bit size */
940 switch (params_format(params)) {
941 case SNDRV_PCM_FORMAT_S16_LE:
942 break;
943 case SNDRV_PCM_FORMAT_S20_3LE:
944 voice |= 0x0004;
945 break;
946 case SNDRV_PCM_FORMAT_S24_LE:
947 voice |= 0x0008;
948 break;
949 case SNDRV_PCM_FORMAT_S32_LE:
950 voice |= 0x000c;
951 break;
952 }
953
954 /* sample rate */
955 if (params_rate(params) * 384 == wm8753->pcmclk)
956 srate |= 0x80;
957 wm8753_write(codec, WM8753_SRATE1, srate);
958
959 wm8753_write(codec, WM8753_PCM, voice);
960 return 0;
961}
962
963/*
964 * Set's PCM dai fmt and BCLK.
965 */
966static int wm8753_pcm_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
967 unsigned int fmt)
968{
969 struct snd_soc_codec *codec = codec_dai->codec;
970 u16 voice, ioctl;
971
972 voice = wm8753_read_reg_cache(codec, WM8753_PCM) & 0x011f;
973 ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x015d;
974
975 /* set master/slave audio interface */
976 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
977 case SND_SOC_DAIFMT_CBS_CFS:
978 break;
979 case SND_SOC_DAIFMT_CBM_CFM:
980 ioctl |= 0x2;
981 case SND_SOC_DAIFMT_CBM_CFS:
982 voice |= 0x0040;
983 break;
984 default:
985 return -EINVAL;
986 }
987
988 /* clock inversion */
989 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
990 case SND_SOC_DAIFMT_DSP_A:
991 case SND_SOC_DAIFMT_DSP_B:
992 /* frame inversion not valid for DSP modes */
993 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
994 case SND_SOC_DAIFMT_NB_NF:
995 break;
996 case SND_SOC_DAIFMT_IB_NF:
997 voice |= 0x0080;
998 break;
999 default:
1000 return -EINVAL;
1001 }
1002 break;
1003 case SND_SOC_DAIFMT_I2S:
1004 case SND_SOC_DAIFMT_RIGHT_J:
1005 case SND_SOC_DAIFMT_LEFT_J:
1006 voice &= ~0x0010;
1007 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1008 case SND_SOC_DAIFMT_NB_NF:
1009 break;
1010 case SND_SOC_DAIFMT_IB_IF:
1011 voice |= 0x0090;
1012 break;
1013 case SND_SOC_DAIFMT_IB_NF:
1014 voice |= 0x0080;
1015 break;
1016 case SND_SOC_DAIFMT_NB_IF:
1017 voice |= 0x0010;
1018 break;
1019 default:
1020 return -EINVAL;
1021 }
1022 break;
1023 default:
1024 return -EINVAL;
1025 }
1026
1027 wm8753_write(codec, WM8753_PCM, voice);
1028 wm8753_write(codec, WM8753_IOCTL, ioctl);
1029 return 0;
1030}
1031
1032static int wm8753_set_dai_clkdiv(struct snd_soc_codec_dai *codec_dai,
1033 int div_id, int div)
1034{
1035 struct snd_soc_codec *codec = codec_dai->codec;
1036 u16 reg;
1037
1038 switch (div_id) {
1039 case WM8753_PCMDIV:
1040 reg = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0x003f;
1041 wm8753_write(codec, WM8753_CLOCK, reg | div);
1042 break;
1043 case WM8753_BCLKDIV:
1044 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x01c7;
1045 wm8753_write(codec, WM8753_SRATE2, reg | div);
1046 break;
1047 case WM8753_VXCLKDIV:
1048 reg = wm8753_read_reg_cache(codec, WM8753_SRATE2) & 0x003f;
1049 wm8753_write(codec, WM8753_SRATE2, reg | div);
1050 break;
1051 default:
1052 return -EINVAL;
1053 }
1054 return 0;
1055}
1056
1057/*
1058 * Set's HiFi DAC format.
1059 */
1060static int wm8753_hdac_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1061 unsigned int fmt)
1062{
1063 struct snd_soc_codec *codec = codec_dai->codec;
1064 u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01e0;
1065
1066 /* interface format */
1067 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1068 case SND_SOC_DAIFMT_I2S:
1069 hifi |= 0x0002;
1070 break;
1071 case SND_SOC_DAIFMT_RIGHT_J:
1072 break;
1073 case SND_SOC_DAIFMT_LEFT_J:
1074 hifi |= 0x0001;
1075 break;
1076 case SND_SOC_DAIFMT_DSP_A:
1077 hifi |= 0x0003;
1078 break;
1079 case SND_SOC_DAIFMT_DSP_B:
1080 hifi |= 0x0013;
1081 break;
1082 default:
1083 return -EINVAL;
1084 }
1085
1086 wm8753_write(codec, WM8753_HIFI, hifi);
1087 return 0;
1088}
1089
1090/*
1091 * Set's I2S DAI format.
1092 */
1093static int wm8753_i2s_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1094 unsigned int fmt)
1095{
1096 struct snd_soc_codec *codec = codec_dai->codec;
1097 u16 ioctl, hifi;
1098
1099 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x011f;
1100 ioctl = wm8753_read_reg_cache(codec, WM8753_IOCTL) & 0x00ae;
1101
1102 /* set master/slave audio interface */
1103 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1104 case SND_SOC_DAIFMT_CBS_CFS:
1105 break;
1106 case SND_SOC_DAIFMT_CBM_CFM:
1107 ioctl |= 0x1;
1108 case SND_SOC_DAIFMT_CBM_CFS:
1109 hifi |= 0x0040;
1110 break;
1111 default:
1112 return -EINVAL;
1113 }
1114
1115 /* clock inversion */
1116 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1117 case SND_SOC_DAIFMT_DSP_A:
1118 case SND_SOC_DAIFMT_DSP_B:
1119 /* frame inversion not valid for DSP modes */
1120 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1121 case SND_SOC_DAIFMT_NB_NF:
1122 break;
1123 case SND_SOC_DAIFMT_IB_NF:
1124 hifi |= 0x0080;
1125 break;
1126 default:
1127 return -EINVAL;
1128 }
1129 break;
1130 case SND_SOC_DAIFMT_I2S:
1131 case SND_SOC_DAIFMT_RIGHT_J:
1132 case SND_SOC_DAIFMT_LEFT_J:
1133 hifi &= ~0x0010;
1134 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1135 case SND_SOC_DAIFMT_NB_NF:
1136 break;
1137 case SND_SOC_DAIFMT_IB_IF:
1138 hifi |= 0x0090;
1139 break;
1140 case SND_SOC_DAIFMT_IB_NF:
1141 hifi |= 0x0080;
1142 break;
1143 case SND_SOC_DAIFMT_NB_IF:
1144 hifi |= 0x0010;
1145 break;
1146 default:
1147 return -EINVAL;
1148 }
1149 break;
1150 default:
1151 return -EINVAL;
1152 }
1153
1154 wm8753_write(codec, WM8753_HIFI, hifi);
1155 wm8753_write(codec, WM8753_IOCTL, ioctl);
1156 return 0;
1157}
1158
1159/*
1160 * Set PCM DAI bit size and sample rate.
1161 */
1162static int wm8753_i2s_hw_params(struct snd_pcm_substream *substream,
1163 struct snd_pcm_hw_params *params)
1164{
1165 struct snd_soc_pcm_runtime *rtd = substream->private_data;
1166 struct snd_soc_device *socdev = rtd->socdev;
1167 struct snd_soc_codec *codec = socdev->codec;
1168 struct wm8753_priv *wm8753 = codec->private_data;
1169 u16 srate = wm8753_read_reg_cache(codec, WM8753_SRATE1) & 0x01c0;
1170 u16 hifi = wm8753_read_reg_cache(codec, WM8753_HIFI) & 0x01f3;
1171 int coeff;
1172
1173 /* is digital filter coefficient valid ? */
1174 coeff = get_coeff(wm8753->sysclk, params_rate(params));
1175 if (coeff < 0) {
1176 printk(KERN_ERR "wm8753 invalid MCLK or rate\n");
1177 return coeff;
1178 }
1179 wm8753_write(codec, WM8753_SRATE1, srate | (coeff_div[coeff].sr << 1) |
1180 coeff_div[coeff].usb);
1181
1182 /* bit size */
1183 switch (params_format(params)) {
1184 case SNDRV_PCM_FORMAT_S16_LE:
1185 break;
1186 case SNDRV_PCM_FORMAT_S20_3LE:
1187 hifi |= 0x0004;
1188 break;
1189 case SNDRV_PCM_FORMAT_S24_LE:
1190 hifi |= 0x0008;
1191 break;
1192 case SNDRV_PCM_FORMAT_S32_LE:
1193 hifi |= 0x000c;
1194 break;
1195 }
1196
1197 wm8753_write(codec, WM8753_HIFI, hifi);
1198 return 0;
1199}
1200
1201static int wm8753_mode1v_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1202 unsigned int fmt)
1203{
1204 struct snd_soc_codec *codec = codec_dai->codec;
1205 u16 clock;
1206
1207 /* set clk source as pcmclk */
1208 clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1209 wm8753_write(codec, WM8753_CLOCK, clock);
1210
1211 if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1212 return -EINVAL;
1213 return wm8753_pcm_set_dai_fmt(codec_dai, fmt);
1214}
1215
1216static int wm8753_mode1h_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1217 unsigned int fmt)
1218{
1219 if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1220 return -EINVAL;
1221 return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1222}
1223
1224static int wm8753_mode2_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1225 unsigned int fmt)
1226{
1227 struct snd_soc_codec *codec = codec_dai->codec;
1228 u16 clock;
1229
1230 /* set clk source as pcmclk */
1231 clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1232 wm8753_write(codec, WM8753_CLOCK, clock);
1233
1234 if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1235 return -EINVAL;
1236 return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1237}
1238
1239static int wm8753_mode3_4_set_dai_fmt(struct snd_soc_codec_dai *codec_dai,
1240 unsigned int fmt)
1241{
1242 struct snd_soc_codec *codec = codec_dai->codec;
1243 u16 clock;
1244
1245 /* set clk source as mclk */
1246 clock = wm8753_read_reg_cache(codec, WM8753_CLOCK) & 0xfffb;
1247 wm8753_write(codec, WM8753_CLOCK, clock | 0x4);
1248
1249 if (wm8753_hdac_set_dai_fmt(codec_dai, fmt) < 0)
1250 return -EINVAL;
1251 if (wm8753_vdac_adc_set_dai_fmt(codec_dai, fmt) < 0)
1252 return -EINVAL;
1253 return wm8753_i2s_set_dai_fmt(codec_dai, fmt);
1254}
1255
1256static int wm8753_mute(struct snd_soc_codec_dai *dai, int mute)
1257{
1258 struct snd_soc_codec *codec = dai->codec;
1259 u16 mute_reg = wm8753_read_reg_cache(codec, WM8753_DAC) & 0xfff7;
1260
1261 /* the digital mute covers the HiFi and Voice DAC's on the WM8753.
1262 * make sure we check if they are not both active when we mute */
1263 if (mute && dai->id == 1) {
1264 if (!wm8753_dai[WM8753_DAI_VOICE].playback.active ||
1265 !wm8753_dai[WM8753_DAI_HIFI].playback.active)
1266 wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1267 } else {
1268 if (mute)
1269 wm8753_write(codec, WM8753_DAC, mute_reg | 0x8);
1270 else
1271 wm8753_write(codec, WM8753_DAC, mute_reg);
1272 }
1273
1274 return 0;
1275}
1276
1277static int wm8753_dapm_event(struct snd_soc_codec *codec, int event)
1278{
1279 u16 pwr_reg = wm8753_read_reg_cache(codec, WM8753_PWR1) & 0xfe3e;
1280
1281 switch (event) {
1282 case SNDRV_CTL_POWER_D0: /* full On */
1283 /* set vmid to 50k and unmute dac */
1284 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x00c0);
1285 break;
1286 case SNDRV_CTL_POWER_D1: /* partial On */
1287 case SNDRV_CTL_POWER_D2: /* partial On */
1288 /* set vmid to 5k for quick power up */
1289 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
1290 break;
1291 case SNDRV_CTL_POWER_D3hot: /* Off, with power */
1292 /* mute dac and set vmid to 500k, enable VREF */
1293 wm8753_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
1294 break;
1295 case SNDRV_CTL_POWER_D3cold: /* Off, without power */
1296 wm8753_write(codec, WM8753_PWR1, 0x0001);
1297 break;
1298 }
1299 codec->dapm_state = event;
1300 return 0;
1301}
1302
1303#define WM8753_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
60fc684a
MB		 1304 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
1305 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
1306 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
1f53aee0
LG		 1307
1308#define WM8753_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
1309 SNDRV_PCM_FMTBIT_S24_LE)
1310
1311/*
1312 * The WM8753 supports upto 4 different and mutually exclusive DAI
1313 * configurations. This gives 2 PCM's available for use, hifi and voice.
1314 * NOTE: The Voice PCM cannot play or capture audio to the CPU as it's DAI
1315 * is connected between the wm8753 and a BT codec or GSM modem.
1316 *
1317 * 1. Voice over PCM DAI - HIFI DAC over HIFI DAI
1318 * 2. Voice over HIFI DAI - HIFI disabled
1319 * 3. Voice disabled - HIFI over HIFI
1320 * 4. Voice disabled - HIFI over HIFI, uses voice DAI LRC for capture
1321 */
1322static const struct snd_soc_codec_dai wm8753_all_dai[] = {
1323/* DAI HiFi mode 1 */
1324{ .name = "WM8753 HiFi",
1325 .id = 1,
1326 .playback = {
1327 .stream_name = "HiFi Playback",
1328 .channels_min = 1,
1329 .channels_max = 2,
1330 .rates = WM8753_RATES,
1331 .formats = WM8753_FORMATS,},
1332 .capture = { /* dummy for fast DAI switching */
1333 .stream_name = "Capture",
1334 .channels_min = 1,
1335 .channels_max = 2,
1336 .rates = WM8753_RATES,
1337 .formats = WM8753_FORMATS,},
1338 .ops = {
1339 .hw_params = wm8753_i2s_hw_params,},
1340 .dai_ops = {
1341 .digital_mute = wm8753_mute,
1342 .set_fmt = wm8753_mode1h_set_dai_fmt,
1343 .set_clkdiv = wm8753_set_dai_clkdiv,
1344 .set_pll = wm8753_set_dai_pll,
1345 .set_sysclk = wm8753_set_dai_sysclk,
1346 },
1347},
1348/* DAI Voice mode 1 */
1349{ .name = "WM8753 Voice",
1350 .id = 1,
1351 .playback = {
1352 .stream_name = "Voice Playback",
1353 .channels_min = 1,
1354 .channels_max = 1,
1355 .rates = WM8753_RATES,
1356 .formats = WM8753_FORMATS,},
1357 .capture = {
1358 .stream_name = "Capture",
1359 .channels_min = 1,
1360 .channels_max = 2,
1361 .rates = WM8753_RATES,
1362 .formats = WM8753_FORMATS,},
1363 .ops = {
1364 .hw_params = wm8753_pcm_hw_params,},
1365 .dai_ops = {
1366 .digital_mute = wm8753_mute,
1367 .set_fmt = wm8753_mode1v_set_dai_fmt,
1368 .set_clkdiv = wm8753_set_dai_clkdiv,
1369 .set_pll = wm8753_set_dai_pll,
1370 .set_sysclk = wm8753_set_dai_sysclk,
1371 },
1372},
1373/* DAI HiFi mode 2 - dummy */
1374{ .name = "WM8753 HiFi",
1375 .id = 2,
1376},
1377/* DAI Voice mode 2 */
1378{ .name = "WM8753 Voice",
1379 .id = 2,
1380 .playback = {
1381 .stream_name = "Voice Playback",
1382 .channels_min = 1,
1383 .channels_max = 1,
1384 .rates = WM8753_RATES,
1385 .formats = WM8753_FORMATS,},
1386 .capture = {
1387 .stream_name = "Capture",
1388 .channels_min = 1,
1389 .channels_max = 2,
1390 .rates = WM8753_RATES,
1391 .formats = WM8753_FORMATS,},
1392 .ops = {
1393 .hw_params = wm8753_pcm_hw_params,},
1394 .dai_ops = {
1395 .digital_mute = wm8753_mute,
1396 .set_fmt = wm8753_mode2_set_dai_fmt,
1397 .set_clkdiv = wm8753_set_dai_clkdiv,
1398 .set_pll = wm8753_set_dai_pll,
1399 .set_sysclk = wm8753_set_dai_sysclk,
1400 },
1401},
1402/* DAI HiFi mode 3 */
1403{ .name = "WM8753 HiFi",
1404 .id = 3,
1405 .playback = {
1406 .stream_name = "HiFi Playback",
1407 .channels_min = 1,
1408 .channels_max = 2,
1409 .rates = WM8753_RATES,
1410 .formats = WM8753_FORMATS,},
1411 .capture = {
1412 .stream_name = "Capture",
1413 .channels_min = 1,
1414 .channels_max = 2,
1415 .rates = WM8753_RATES,
1416 .formats = WM8753_FORMATS,},
1417 .ops = {
1418 .hw_params = wm8753_i2s_hw_params,},
1419 .dai_ops = {
1420 .digital_mute = wm8753_mute,
1421 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1422 .set_clkdiv = wm8753_set_dai_clkdiv,
1423 .set_pll = wm8753_set_dai_pll,
1424 .set_sysclk = wm8753_set_dai_sysclk,
1425 },
1426},
1427/* DAI Voice mode 3 - dummy */
1428{ .name = "WM8753 Voice",
1429 .id = 3,
1430},
1431/* DAI HiFi mode 4 */
1432{ .name = "WM8753 HiFi",
1433 .id = 4,
1434 .playback = {
1435 .stream_name = "HiFi Playback",
1436 .channels_min = 1,
1437 .channels_max = 2,
1438 .rates = WM8753_RATES,
1439 .formats = WM8753_FORMATS,},
1440 .capture = {
1441 .stream_name = "Capture",
1442 .channels_min = 1,
1443 .channels_max = 2,
1444 .rates = WM8753_RATES,
1445 .formats = WM8753_FORMATS,},
1446 .ops = {
1447 .hw_params = wm8753_i2s_hw_params,},
1448 .dai_ops = {
1449 .digital_mute = wm8753_mute,
1450 .set_fmt = wm8753_mode3_4_set_dai_fmt,
1451 .set_clkdiv = wm8753_set_dai_clkdiv,
1452 .set_pll = wm8753_set_dai_pll,
1453 .set_sysclk = wm8753_set_dai_sysclk,
1454 },
1455},
1456/* DAI Voice mode 4 - dummy */
1457{ .name = "WM8753 Voice",
1458 .id = 4,
1459},
1460};
1461
1462struct snd_soc_codec_dai wm8753_dai[2];
1463EXPORT_SYMBOL_GPL(wm8753_dai);
1464
1465static void wm8753_set_dai_mode(struct snd_soc_codec *codec, unsigned int mode)
1466{
1467 if (mode < 4) {
1468 int playback_active, capture_active, codec_active, pop_wait;
1469 void *private_data;
1470
1471 playback_active = wm8753_dai[0].playback.active;
1472 capture_active = wm8753_dai[0].capture.active;
1473 codec_active = wm8753_dai[0].active;
1474 private_data = wm8753_dai[0].private_data;
1475 pop_wait = wm8753_dai[0].pop_wait;
1476 wm8753_dai[0] = wm8753_all_dai[mode << 1];
1477 wm8753_dai[0].playback.active = playback_active;
1478 wm8753_dai[0].capture.active = capture_active;
1479 wm8753_dai[0].active = codec_active;
1480 wm8753_dai[0].private_data = private_data;
1481 wm8753_dai[0].pop_wait = pop_wait;
1482
1483 playback_active = wm8753_dai[1].playback.active;
1484 capture_active = wm8753_dai[1].capture.active;
1485 codec_active = wm8753_dai[1].active;
1486 private_data = wm8753_dai[1].private_data;
1487 pop_wait = wm8753_dai[1].pop_wait;
1488 wm8753_dai[1] = wm8753_all_dai[(mode << 1) + 1];
1489 wm8753_dai[1].playback.active = playback_active;
1490 wm8753_dai[1].capture.active = capture_active;
1491 wm8753_dai[1].active = codec_active;
1492 wm8753_dai[1].private_data = private_data;
1493 wm8753_dai[1].pop_wait = pop_wait;
1494 }
1495 wm8753_dai[0].codec = codec;
1496 wm8753_dai[1].codec = codec;
1497}
1498
1499static void wm8753_work(struct work_struct *work)
1500{
1501 struct snd_soc_codec *codec =
1502 container_of(work, struct snd_soc_codec, delayed_work.work);
1503 wm8753_dapm_event(codec, codec->dapm_state);
1504}
1505
1506static int wm8753_suspend(struct platform_device *pdev, pm_message_t state)
1507{
1508 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1509 struct snd_soc_codec *codec = socdev->codec;
1510
1511 /* we only need to suspend if we are a valid card */
60fc684a 1512 if (!codec->card)
1f53aee0 1513 return 0;
60fc684a 1514
1f53aee0
LG		 1515 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3cold);
1516 return 0;
1517}
1518
1519static int wm8753_resume(struct platform_device *pdev)
1520{
1521 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1522 struct snd_soc_codec *codec = socdev->codec;
1523 int i;
1524 u8 data[2];
1525 u16 *cache = codec->reg_cache;
1526
1527 /* we only need to resume if we are a valid card */
60fc684a 1528 if (!codec->card)
1f53aee0
LG		 1529 return 0;
1530
1531 /* Sync reg_cache with the hardware */
1532 for (i = 0; i < ARRAY_SIZE(wm8753_reg); i++) {
1533 if (i + 1 == WM8753_RESET)
1534 continue;
1535 data[0] = ((i + 1) << 1) | ((cache[i] >> 8) & 0x0001);
1536 data[1] = cache[i] & 0x00ff;
1537 codec->hw_write(codec->control_data, data, 2);
1538 }
1539
1540 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3hot);
1541
1542 /* charge wm8753 caps */
1543 if (codec->suspend_dapm_state == SNDRV_CTL_POWER_D0) {
1544 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D2);
1545 codec->dapm_state = SNDRV_CTL_POWER_D0;
1546 schedule_delayed_work(&codec->delayed_work,
1547 msecs_to_jiffies(caps_charge));
1548 }
1549
1550 return 0;
1551}
1552
1553/*
1554 * initialise the WM8753 driver
1555 * register the mixer and dsp interfaces with the kernel
1556 */
1557static int wm8753_init(struct snd_soc_device *socdev)
1558{
1559 struct snd_soc_codec *codec = socdev->codec;
1560 int reg, ret = 0;
1561
1562 codec->name = "WM8753";
1563 codec->owner = THIS_MODULE;
1564 codec->read = wm8753_read_reg_cache;
1565 codec->write = wm8753_write;
1566 codec->dapm_event = wm8753_dapm_event;
1567 codec->dai = wm8753_dai;
1568 codec->num_dai = 2;
1569 codec->reg_cache_size = sizeof(wm8753_reg);
1570 codec->reg_cache = kmemdup(wm8753_reg, sizeof(wm8753_reg), GFP_KERNEL);
1571
1572 if (codec->reg_cache == NULL)
1573 return -ENOMEM;
1574
1575 wm8753_set_dai_mode(codec, 0);
1576
1577 wm8753_reset(codec);
1578
1579 /* register pcms */
1580 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
1581 if (ret < 0) {
1582 printk(KERN_ERR "wm8753: failed to create pcms\n");
1583 goto pcm_err;
1584 }
1585
1586 /* charge output caps */
1587 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D2);
1588 codec->dapm_state = SNDRV_CTL_POWER_D3hot;
1589 schedule_delayed_work(&codec->delayed_work,
1590 msecs_to_jiffies(caps_charge));
1591
1592 /* set the update bits */
1593 reg = wm8753_read_reg_cache(codec, WM8753_LDAC);
1594 wm8753_write(codec, WM8753_LDAC, reg | 0x0100);
1595 reg = wm8753_read_reg_cache(codec, WM8753_RDAC);
1596 wm8753_write(codec, WM8753_RDAC, reg | 0x0100);
1597 reg = wm8753_read_reg_cache(codec, WM8753_LADC);
1598 wm8753_write(codec, WM8753_LADC, reg | 0x0100);
1599 reg = wm8753_read_reg_cache(codec, WM8753_RADC);
1600 wm8753_write(codec, WM8753_RADC, reg | 0x0100);
1601 reg = wm8753_read_reg_cache(codec, WM8753_LOUT1V);
1602 wm8753_write(codec, WM8753_LOUT1V, reg | 0x0100);
1603 reg = wm8753_read_reg_cache(codec, WM8753_ROUT1V);
1604 wm8753_write(codec, WM8753_ROUT1V, reg | 0x0100);
1605 reg = wm8753_read_reg_cache(codec, WM8753_LOUT2V);
1606 wm8753_write(codec, WM8753_LOUT2V, reg | 0x0100);
1607 reg = wm8753_read_reg_cache(codec, WM8753_ROUT2V);
1608 wm8753_write(codec, WM8753_ROUT2V, reg | 0x0100);
1609 reg = wm8753_read_reg_cache(codec, WM8753_LINVOL);
1610 wm8753_write(codec, WM8753_LINVOL, reg | 0x0100);
1611 reg = wm8753_read_reg_cache(codec, WM8753_RINVOL);
1612 wm8753_write(codec, WM8753_RINVOL, reg | 0x0100);
1613
1614 wm8753_add_controls(codec);
1615 wm8753_add_widgets(codec);
1616 ret = snd_soc_register_card(socdev);
1617 if (ret < 0) {
60fc684a 1618 printk(KERN_ERR "wm8753: failed to register card\n");
1f53aee0 1619 goto card_err;
60fc684a
MB		 1620 }
1621
1f53aee0
LG		 1622 return ret;
1623
1624card_err:
1625 snd_soc_free_pcms(socdev);
1626 snd_soc_dapm_free(socdev);
1627pcm_err:
1628 kfree(codec->reg_cache);
1629 return ret;
1630}
1631
1632/* If the i2c layer weren't so broken, we could pass this kind of data
1633 around */
1634static struct snd_soc_device *wm8753_socdev;
1635
60fc684a 1636#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1f53aee0
LG		 1637
1638/*
1639 * WM8753 2 wire address is determined by GPIO5
1640 * state during powerup.
1641 * low = 0x1a
1642 * high = 0x1b
1643 */
1644static unsigned short normal_i2c[] = { 0, I2C_CLIENT_END };
1645
1646/* Magic definition of all other variables and things */
1647I2C_CLIENT_INSMOD;
1648
1649static struct i2c_driver wm8753_i2c_driver;
1650static struct i2c_client client_template;
1651
1652static int wm8753_codec_probe(struct i2c_adapter *adap, int addr, int kind)
1653{
1654 struct snd_soc_device *socdev = wm8753_socdev;
1655 struct wm8753_setup_data *setup = socdev->codec_data;
1656 struct snd_soc_codec *codec = socdev->codec;
1657 struct i2c_client *i2c;
1658 int ret;
1659
1660 if (addr != setup->i2c_address)
1661 return -ENODEV;
1662
1663 client_template.adapter = adap;
1664 client_template.addr = addr;
1665
1666 i2c = kmemdup(&client_template, sizeof(client_template), GFP_KERNEL);
60fc684a 1667 if (!i2c) {
1f53aee0
LG		 1668 kfree(codec);
1669 return -ENOMEM;
1670 }
1671 i2c_set_clientdata(i2c, codec);
1672 codec->control_data = i2c;
1673
1674 ret = i2c_attach_client(i2c);
1675 if (ret < 0) {
1676 err("failed to attach codec at addr %x\n", addr);
1677 goto err;
1678 }
1679
1680 ret = wm8753_init(socdev);
1681 if (ret < 0) {
1682 err("failed to initialise WM8753\n");
1683 goto err;
1684 }
1685
1686 return ret;
1687
1688err:
1689 kfree(codec);
1690 kfree(i2c);
1691 return ret;
1692}
1693
1694static int wm8753_i2c_detach(struct i2c_client *client)
1695{
1696 struct snd_soc_codec *codec = i2c_get_clientdata(client);
1697 i2c_detach_client(client);
1698 kfree(codec->reg_cache);
1699 kfree(client);
1700 return 0;
1701}
1702
1703static int wm8753_i2c_attach(struct i2c_adapter *adap)
1704{
1705 return i2c_probe(adap, &addr_data, wm8753_codec_probe);
1706}
1707
1708/* corgi i2c codec control layer */
1709static struct i2c_driver wm8753_i2c_driver = {
1710 .driver = {
1711 .name = "WM8753 I2C Codec",
1712 .owner = THIS_MODULE,
1713 },
1714 .id = I2C_DRIVERID_WM8753,
1715 .attach_adapter = wm8753_i2c_attach,
1716 .detach_client = wm8753_i2c_detach,
1717 .command = NULL,
1718};
1719
1720static struct i2c_client client_template = {
1721 .name = "WM8753",
1722 .driver = &wm8753_i2c_driver,
1723};
1724#endif
1725
1726static int wm8753_probe(struct platform_device *pdev)
1727{
1728 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1729 struct wm8753_setup_data *setup;
1730 struct snd_soc_codec *codec;
1731 struct wm8753_priv *wm8753;
1732 int ret = 0;
1733
1734 info("WM8753 Audio Codec %s", WM8753_VERSION);
1735
1736 setup = socdev->codec_data;
1737 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
1738 if (codec == NULL)
1739 return -ENOMEM;
1740
1741 wm8753 = kzalloc(sizeof(struct wm8753_priv), GFP_KERNEL);
1742 if (wm8753 == NULL) {
1743 kfree(codec);
1744 return -ENOMEM;
1745 }
1746
1747 codec->private_data = wm8753;
1748 socdev->codec = codec;
1749 mutex_init(&codec->mutex);
1750 INIT_LIST_HEAD(&codec->dapm_widgets);
1751 INIT_LIST_HEAD(&codec->dapm_paths);
1752 wm8753_socdev = socdev;
1753 INIT_DELAYED_WORK(&codec->delayed_work, wm8753_work);
1754
60fc684a 1755#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1f53aee0
LG		 1756 if (setup->i2c_address) {
1757 normal_i2c[0] = setup->i2c_address;
1758 codec->hw_write = (hw_write_t)i2c_master_send;
1759 ret = i2c_add_driver(&wm8753_i2c_driver);
1760 if (ret != 0)
1761 printk(KERN_ERR "can't add i2c driver");
1762 }
1763#else
1764 /* Add other interfaces here */
1765#endif
1766 return ret;
1767}
1768
1769/*
1770 * This function forces any delayed work to be queued and run.
1771 */
1772static int run_delayed_work(struct delayed_work *dwork)
1773{
1774 int ret;
1775
1776 /* cancel any work waiting to be queued. */
1777 ret = cancel_delayed_work(dwork);
1778
1779 /* if there was any work waiting then we run it now and
1780 * wait for it's completion */
1781 if (ret) {
1782 schedule_delayed_work(dwork, 0);
1783 flush_scheduled_work();
1784 }
1785 return ret;
1786}
1787
1788/* power down chip */
1789static int wm8753_remove(struct platform_device *pdev)
1790{
1791 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1792 struct snd_soc_codec *codec = socdev->codec;
1793
1794 if (codec->control_data)
1795 wm8753_dapm_event(codec, SNDRV_CTL_POWER_D3cold);
1796 run_delayed_work(&codec->delayed_work);
1797 snd_soc_free_pcms(socdev);
1798 snd_soc_dapm_free(socdev);
60fc684a 1799#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
1f53aee0
LG		 1800 i2c_del_driver(&wm8753_i2c_driver);
1801#endif
1802 kfree(codec->private_data);
1803 kfree(codec);
1804
1805 return 0;
1806}
1807
1808struct snd_soc_codec_device soc_codec_dev_wm8753 = {
1809 .probe = wm8753_probe,
1810 .remove = wm8753_remove,
1811 .suspend = wm8753_suspend,
1812 .resume = wm8753_resume,
1813};
1f53aee0
LG		 1814EXPORT_SYMBOL_GPL(soc_codec_dev_wm8753);
1815
1816MODULE_DESCRIPTION("ASoC WM8753 driver");
1817MODULE_AUTHOR("Liam Girdwood");
1818MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)