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