← Back to branch summary

~ctf/alsa-driver/tiwai-trunk2.bazooka_dock

« back to all changes in this revision

Viewing changes to soc/codecs/wm8960.c

  • Committer: Canonistack server
  • Date: 2015-01-22 13:04:34 UTC
  • Revision ID: david.henningsson@canonical.com-20150122130434-q48cfdp8ovzgqhe7
Test run of 623 machines: 3 failing with 3 errors and 0 warnings.

Show diffs side-by-side

added added

removed removed

Lines of Context:
soc/codecs/wm8960.c
 
1
/*
 
2
 * wm8960.c  --  WM8960 ALSA SoC Audio driver
 
3
 *
 
4
 * Copyright 2007-11 Wolfson Microelectronics, plc
 
5
 *
 
6
 * Author: Liam Girdwood
 
7
 *
 
8
 * This program is free software; you can redistribute it and/or modify
 
9
 * it under the terms of the GNU General Public License version 2 as
 
10
 * published by the Free Software Foundation.
 
11
 */
 
12
 
 
13
#include <linux/module.h>
 
14
#include <linux/moduleparam.h>
 
15
#include <linux/init.h>
 
16
#include <linux/delay.h>
 
17
#include <linux/pm.h>
 
18
#include <linux/i2c.h>
 
19
#include <linux/slab.h>
 
20
#include <sound/core.h>
 
21
#include <sound/pcm.h>
 
22
#include <sound/pcm_params.h>
 
23
#include <sound/soc.h>
 
24
#include <sound/initval.h>
 
25
#include <sound/tlv.h>
 
26
#include <sound/wm8960.h>
 
27
 
 
28
#include "wm8960.h"
 
29
 
 
30
/* R25 - Power 1 */
 
31
#define WM8960_VMID_MASK 0x180
 
32
#define WM8960_VREF      0x40
 
33
 
 
34
/* R26 - Power 2 */
 
35
#define WM8960_PWR2_LOUT1       0x40
 
36
#define WM8960_PWR2_ROUT1       0x20
 
37
#define WM8960_PWR2_OUT3        0x02
 
38
 
 
39
/* R28 - Anti-pop 1 */
 
40
#define WM8960_POBCTRL   0x80
 
41
#define WM8960_BUFDCOPEN 0x10
 
42
#define WM8960_BUFIOEN   0x08
 
43
#define WM8960_SOFT_ST   0x04
 
44
#define WM8960_HPSTBY    0x01
 
45
 
 
46
/* R29 - Anti-pop 2 */
 
47
#define WM8960_DISOP     0x40
 
48
#define WM8960_DRES_MASK 0x30
 
49
 
 
50
/*
 
51
 * wm8960 register cache
 
52
 * We can't read the WM8960 register space when we are
 
53
 * using 2 wire for device control, so we cache them instead.
 
54
 */
 
55
static const struct reg_default wm8960_reg_defaults[] = {
 
56
        {  0x0, 0x00a7 },
 
57
        {  0x1, 0x00a7 },
 
58
        {  0x2, 0x0000 },
 
59
        {  0x3, 0x0000 },
 
60
        {  0x4, 0x0000 },
 
61
        {  0x5, 0x0008 },
 
62
        {  0x6, 0x0000 },
 
63
        {  0x7, 0x000a },
 
64
        {  0x8, 0x01c0 },
 
65
        {  0x9, 0x0000 },
 
66
        {  0xa, 0x00ff },
 
67
        {  0xb, 0x00ff },
 
68
 
 
69
        { 0x10, 0x0000 },
 
70
        { 0x11, 0x007b },
 
71
        { 0x12, 0x0100 },
 
72
        { 0x13, 0x0032 },
 
73
        { 0x14, 0x0000 },
 
74
        { 0x15, 0x00c3 },
 
75
        { 0x16, 0x00c3 },
 
76
        { 0x17, 0x01c0 },
 
77
        { 0x18, 0x0000 },
 
78
        { 0x19, 0x0000 },
 
79
        { 0x1a, 0x0000 },
 
80
        { 0x1b, 0x0000 },
 
81
        { 0x1c, 0x0000 },
 
82
        { 0x1d, 0x0000 },
 
83
 
 
84
        { 0x20, 0x0100 },
 
85
        { 0x21, 0x0100 },
 
86
        { 0x22, 0x0050 },
 
87
 
 
88
        { 0x25, 0x0050 },
 
89
        { 0x26, 0x0000 },
 
90
        { 0x27, 0x0000 },
 
91
        { 0x28, 0x0000 },
 
92
        { 0x29, 0x0000 },
 
93
        { 0x2a, 0x0040 },
 
94
        { 0x2b, 0x0000 },
 
95
        { 0x2c, 0x0000 },
 
96
        { 0x2d, 0x0050 },
 
97
        { 0x2e, 0x0050 },
 
98
        { 0x2f, 0x0000 },
 
99
        { 0x30, 0x0002 },
 
100
        { 0x31, 0x0037 },
 
101
 
 
102
        { 0x33, 0x0080 },
 
103
        { 0x34, 0x0008 },
 
104
        { 0x35, 0x0031 },
 
105
        { 0x36, 0x0026 },
 
106
        { 0x37, 0x00e9 },
 
107
};
 
108
 
 
109
static bool wm8960_volatile(struct device *dev, unsigned int reg)
 
110
{
 
111
        switch (reg) {
 
112
        case WM8960_RESET:
 
113
                return true;
 
114
        default:
 
115
                return false;
 
116
        }
 
117
}
 
118
 
 
119
struct wm8960_priv {
 
120
        struct regmap *regmap;
 
121
        int (*set_bias_level)(struct snd_soc_codec *,
 
122
                              enum snd_soc_bias_level level);
 
123
        struct snd_soc_dapm_widget *lout1;
 
124
        struct snd_soc_dapm_widget *rout1;
 
125
        struct snd_soc_dapm_widget *out3;
 
126
        bool deemph;
 
127
        int playback_fs;
 
128
        struct wm8960_data pdata;
 
129
};
 
130
 
 
131
#define wm8960_reset(c) regmap_write(c, WM8960_RESET, 0)
 
132
 
 
133
/* enumerated controls */
 
134
static const char *wm8960_polarity[] = {"No Inversion", "Left Inverted",
 
135
        "Right Inverted", "Stereo Inversion"};
 
136
static const char *wm8960_3d_upper_cutoff[] = {"High", "Low"};
 
137
static const char *wm8960_3d_lower_cutoff[] = {"Low", "High"};
 
138
static const char *wm8960_alcfunc[] = {"Off", "Right", "Left", "Stereo"};
 
139
static const char *wm8960_alcmode[] = {"ALC", "Limiter"};
 
140
 
 
141
static const struct soc_enum wm8960_enum[] = {
 
142
        SOC_ENUM_SINGLE(WM8960_DACCTL1, 5, 4, wm8960_polarity),
 
143
        SOC_ENUM_SINGLE(WM8960_DACCTL2, 5, 4, wm8960_polarity),
 
144
        SOC_ENUM_SINGLE(WM8960_3D, 6, 2, wm8960_3d_upper_cutoff),
 
145
        SOC_ENUM_SINGLE(WM8960_3D, 5, 2, wm8960_3d_lower_cutoff),
 
146
        SOC_ENUM_SINGLE(WM8960_ALC1, 7, 4, wm8960_alcfunc),
 
147
        SOC_ENUM_SINGLE(WM8960_ALC3, 8, 2, wm8960_alcmode),
 
148
};
 
149
 
 
150
static const int deemph_settings[] = { 0, 32000, 44100, 48000 };
 
151
 
 
152
static int wm8960_set_deemph(struct snd_soc_codec *codec)
 
153
{
 
154
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
155
        int val, i, best;
 
156
 
 
157
        /* If we're using deemphasis select the nearest available sample
 
158
         * rate.
 
159
         */
 
160
        if (wm8960->deemph) {
 
161
                best = 1;
 
162
                for (i = 2; i < ARRAY_SIZE(deemph_settings); i++) {
 
163
                        if (abs(deemph_settings[i] - wm8960->playback_fs) <
 
164
                            abs(deemph_settings[best] - wm8960->playback_fs))
 
165
                                best = i;
 
166
                }
 
167
 
 
168
                val = best << 1;
 
169
        } else {
 
170
                val = 0;
 
171
        }
 
172
 
 
173
        dev_dbg(codec->dev, "Set deemphasis %d\n", val);
 
174
 
 
175
        return snd_soc_update_bits(codec, WM8960_DACCTL1,
 
176
                                   0x6, val);
 
177
}
 
178
 
 
179
static int wm8960_get_deemph(struct snd_kcontrol *kcontrol,
 
180
                             struct snd_ctl_elem_value *ucontrol)
 
181
{
 
182
        struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 
183
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
184
 
 
185
        ucontrol->value.enumerated.item[0] = wm8960->deemph;
 
186
        return 0;
 
187
}
 
188
 
 
189
static int wm8960_put_deemph(struct snd_kcontrol *kcontrol,
 
190
                             struct snd_ctl_elem_value *ucontrol)
 
191
{
 
192
        struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 
193
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
194
        int deemph = ucontrol->value.enumerated.item[0];
 
195
 
 
196
        if (deemph > 1)
 
197
                return -EINVAL;
 
198
 
 
199
        wm8960->deemph = deemph;
 
200
 
 
201
        return wm8960_set_deemph(codec);
 
202
}
 
203
 
 
204
static const DECLARE_TLV_DB_SCALE(adc_tlv, -9700, 50, 0);
 
205
static const DECLARE_TLV_DB_SCALE(dac_tlv, -12700, 50, 1);
 
206
static const DECLARE_TLV_DB_SCALE(bypass_tlv, -2100, 300, 0);
 
207
static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
 
208
static const DECLARE_TLV_DB_SCALE(boost_tlv, -1200, 300, 1);
 
209
 
 
210
static const struct snd_kcontrol_new wm8960_snd_controls[] = {
 
211
SOC_DOUBLE_R_TLV("Capture Volume", WM8960_LINVOL, WM8960_RINVOL,
 
212
                 0, 63, 0, adc_tlv),
 
213
SOC_DOUBLE_R("Capture Volume ZC Switch", WM8960_LINVOL, WM8960_RINVOL,
 
214
        6, 1, 0),
 
215
SOC_DOUBLE_R("Capture Switch", WM8960_LINVOL, WM8960_RINVOL,
 
216
        7, 1, 0),
 
217
 
 
218
SOC_SINGLE_TLV("Right Input Boost Mixer RINPUT3 Volume",
 
219
               WM8960_INBMIX1, 4, 7, 0, boost_tlv),
 
220
SOC_SINGLE_TLV("Right Input Boost Mixer RINPUT2 Volume",
 
221
               WM8960_INBMIX1, 1, 7, 0, boost_tlv),
 
222
SOC_SINGLE_TLV("Left Input Boost Mixer LINPUT3 Volume",
 
223
               WM8960_INBMIX2, 4, 7, 0, boost_tlv),
 
224
SOC_SINGLE_TLV("Left Input Boost Mixer LINPUT2 Volume",
 
225
               WM8960_INBMIX2, 1, 7, 0, boost_tlv),
 
226
 
 
227
SOC_DOUBLE_R_TLV("Playback Volume", WM8960_LDAC, WM8960_RDAC,
 
228
                 0, 255, 0, dac_tlv),
 
229
 
 
230
SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8960_LOUT1, WM8960_ROUT1,
 
231
                 0, 127, 0, out_tlv),
 
232
SOC_DOUBLE_R("Headphone Playback ZC Switch", WM8960_LOUT1, WM8960_ROUT1,
 
233
        7, 1, 0),
 
234
 
 
235
SOC_DOUBLE_R_TLV("Speaker Playback Volume", WM8960_LOUT2, WM8960_ROUT2,
 
236
                 0, 127, 0, out_tlv),
 
237
SOC_DOUBLE_R("Speaker Playback ZC Switch", WM8960_LOUT2, WM8960_ROUT2,
 
238
        7, 1, 0),
 
239
SOC_SINGLE("Speaker DC Volume", WM8960_CLASSD3, 3, 5, 0),
 
240
SOC_SINGLE("Speaker AC Volume", WM8960_CLASSD3, 0, 5, 0),
 
241
 
 
242
SOC_SINGLE("PCM Playback -6dB Switch", WM8960_DACCTL1, 7, 1, 0),
 
243
SOC_ENUM("ADC Polarity", wm8960_enum[0]),
 
244
SOC_SINGLE("ADC High Pass Filter Switch", WM8960_DACCTL1, 0, 1, 0),
 
245
 
 
246
SOC_ENUM("DAC Polarity", wm8960_enum[2]),
 
247
SOC_SINGLE_BOOL_EXT("DAC Deemphasis Switch", 0,
 
248
                    wm8960_get_deemph, wm8960_put_deemph),
 
249
 
 
250
SOC_ENUM("3D Filter Upper Cut-Off", wm8960_enum[2]),
 
251
SOC_ENUM("3D Filter Lower Cut-Off", wm8960_enum[3]),
 
252
SOC_SINGLE("3D Volume", WM8960_3D, 1, 15, 0),
 
253
SOC_SINGLE("3D Switch", WM8960_3D, 0, 1, 0),
 
254
 
 
255
SOC_ENUM("ALC Function", wm8960_enum[4]),
 
256
SOC_SINGLE("ALC Max Gain", WM8960_ALC1, 4, 7, 0),
 
257
SOC_SINGLE("ALC Target", WM8960_ALC1, 0, 15, 1),
 
258
SOC_SINGLE("ALC Min Gain", WM8960_ALC2, 4, 7, 0),
 
259
SOC_SINGLE("ALC Hold Time", WM8960_ALC2, 0, 15, 0),
 
260
SOC_ENUM("ALC Mode", wm8960_enum[5]),
 
261
SOC_SINGLE("ALC Decay", WM8960_ALC3, 4, 15, 0),
 
262
SOC_SINGLE("ALC Attack", WM8960_ALC3, 0, 15, 0),
 
263
 
 
264
SOC_SINGLE("Noise Gate Threshold", WM8960_NOISEG, 3, 31, 0),
 
265
SOC_SINGLE("Noise Gate Switch", WM8960_NOISEG, 0, 1, 0),
 
266
 
 
267
SOC_DOUBLE_R_TLV("ADC PCM Capture Volume", WM8960_LADC, WM8960_RADC,
 
268
        0, 255, 0, adc_tlv),
 
269
 
 
270
SOC_SINGLE_TLV("Left Output Mixer Boost Bypass Volume",
 
271
               WM8960_BYPASS1, 4, 7, 1, bypass_tlv),
 
272
SOC_SINGLE_TLV("Left Output Mixer LINPUT3 Volume",
 
273
               WM8960_LOUTMIX, 4, 7, 1, bypass_tlv),
 
274
SOC_SINGLE_TLV("Right Output Mixer Boost Bypass Volume",
 
275
               WM8960_BYPASS2, 4, 7, 1, bypass_tlv),
 
276
SOC_SINGLE_TLV("Right Output Mixer RINPUT3 Volume",
 
277
               WM8960_ROUTMIX, 4, 7, 1, bypass_tlv),
 
278
};
 
279
 
 
280
static const struct snd_kcontrol_new wm8960_lin_boost[] = {
 
281
SOC_DAPM_SINGLE("LINPUT2 Switch", WM8960_LINPATH, 6, 1, 0),
 
282
SOC_DAPM_SINGLE("LINPUT3 Switch", WM8960_LINPATH, 7, 1, 0),
 
283
SOC_DAPM_SINGLE("LINPUT1 Switch", WM8960_LINPATH, 8, 1, 0),
 
284
};
 
285
 
 
286
static const struct snd_kcontrol_new wm8960_lin[] = {
 
287
SOC_DAPM_SINGLE("Boost Switch", WM8960_LINPATH, 3, 1, 0),
 
288
};
 
289
 
 
290
static const struct snd_kcontrol_new wm8960_rin_boost[] = {
 
291
SOC_DAPM_SINGLE("RINPUT2 Switch", WM8960_RINPATH, 6, 1, 0),
 
292
SOC_DAPM_SINGLE("RINPUT3 Switch", WM8960_RINPATH, 7, 1, 0),
 
293
SOC_DAPM_SINGLE("RINPUT1 Switch", WM8960_RINPATH, 8, 1, 0),
 
294
};
 
295
 
 
296
static const struct snd_kcontrol_new wm8960_rin[] = {
 
297
SOC_DAPM_SINGLE("Boost Switch", WM8960_RINPATH, 3, 1, 0),
 
298
};
 
299
 
 
300
static const struct snd_kcontrol_new wm8960_loutput_mixer[] = {
 
301
SOC_DAPM_SINGLE("PCM Playback Switch", WM8960_LOUTMIX, 8, 1, 0),
 
302
SOC_DAPM_SINGLE("LINPUT3 Switch", WM8960_LOUTMIX, 7, 1, 0),
 
303
SOC_DAPM_SINGLE("Boost Bypass Switch", WM8960_BYPASS1, 7, 1, 0),
 
304
};
 
305
 
 
306
static const struct snd_kcontrol_new wm8960_routput_mixer[] = {
 
307
SOC_DAPM_SINGLE("PCM Playback Switch", WM8960_ROUTMIX, 8, 1, 0),
 
308
SOC_DAPM_SINGLE("RINPUT3 Switch", WM8960_ROUTMIX, 7, 1, 0),
 
309
SOC_DAPM_SINGLE("Boost Bypass Switch", WM8960_BYPASS2, 7, 1, 0),
 
310
};
 
311
 
 
312
static const struct snd_kcontrol_new wm8960_mono_out[] = {
 
313
SOC_DAPM_SINGLE("Left Switch", WM8960_MONOMIX1, 7, 1, 0),
 
314
SOC_DAPM_SINGLE("Right Switch", WM8960_MONOMIX2, 7, 1, 0),
 
315
};
 
316
 
 
317
static const struct snd_soc_dapm_widget wm8960_dapm_widgets[] = {
 
318
SND_SOC_DAPM_INPUT("LINPUT1"),
 
319
SND_SOC_DAPM_INPUT("RINPUT1"),
 
320
SND_SOC_DAPM_INPUT("LINPUT2"),
 
321
SND_SOC_DAPM_INPUT("RINPUT2"),
 
322
SND_SOC_DAPM_INPUT("LINPUT3"),
 
323
SND_SOC_DAPM_INPUT("RINPUT3"),
 
324
 
 
325
SND_SOC_DAPM_SUPPLY("MICB", WM8960_POWER1, 1, 0, NULL, 0),
 
326
 
 
327
SND_SOC_DAPM_MIXER("Left Boost Mixer", WM8960_POWER1, 5, 0,
 
328
                   wm8960_lin_boost, ARRAY_SIZE(wm8960_lin_boost)),
 
329
SND_SOC_DAPM_MIXER("Right Boost Mixer", WM8960_POWER1, 4, 0,
 
330
                   wm8960_rin_boost, ARRAY_SIZE(wm8960_rin_boost)),
 
331
 
 
332
SND_SOC_DAPM_MIXER("Left Input Mixer", WM8960_POWER3, 5, 0,
 
333
                   wm8960_lin, ARRAY_SIZE(wm8960_lin)),
 
334
SND_SOC_DAPM_MIXER("Right Input Mixer", WM8960_POWER3, 4, 0,
 
335
                   wm8960_rin, ARRAY_SIZE(wm8960_rin)),
 
336
 
 
337
SND_SOC_DAPM_ADC("Left ADC", "Capture", WM8960_POWER1, 3, 0),
 
338
SND_SOC_DAPM_ADC("Right ADC", "Capture", WM8960_POWER1, 2, 0),
 
339
 
 
340
SND_SOC_DAPM_DAC("Left DAC", "Playback", WM8960_POWER2, 8, 0),
 
341
SND_SOC_DAPM_DAC("Right DAC", "Playback", WM8960_POWER2, 7, 0),
 
342
 
 
343
SND_SOC_DAPM_MIXER("Left Output Mixer", WM8960_POWER3, 3, 0,
 
344
        &wm8960_loutput_mixer[0],
 
345
        ARRAY_SIZE(wm8960_loutput_mixer)),
 
346
SND_SOC_DAPM_MIXER("Right Output Mixer", WM8960_POWER3, 2, 0,
 
347
        &wm8960_routput_mixer[0],
 
348
        ARRAY_SIZE(wm8960_routput_mixer)),
 
349
 
 
350
SND_SOC_DAPM_PGA("LOUT1 PGA", WM8960_POWER2, 6, 0, NULL, 0),
 
351
SND_SOC_DAPM_PGA("ROUT1 PGA", WM8960_POWER2, 5, 0, NULL, 0),
 
352
 
 
353
SND_SOC_DAPM_PGA("Left Speaker PGA", WM8960_POWER2, 4, 0, NULL, 0),
 
354
SND_SOC_DAPM_PGA("Right Speaker PGA", WM8960_POWER2, 3, 0, NULL, 0),
 
355
 
 
356
SND_SOC_DAPM_PGA("Right Speaker Output", WM8960_CLASSD1, 7, 0, NULL, 0),
 
357
SND_SOC_DAPM_PGA("Left Speaker Output", WM8960_CLASSD1, 6, 0, NULL, 0),
 
358
 
 
359
SND_SOC_DAPM_OUTPUT("SPK_LP"),
 
360
SND_SOC_DAPM_OUTPUT("SPK_LN"),
 
361
SND_SOC_DAPM_OUTPUT("HP_L"),
 
362
SND_SOC_DAPM_OUTPUT("HP_R"),
 
363
SND_SOC_DAPM_OUTPUT("SPK_RP"),
 
364
SND_SOC_DAPM_OUTPUT("SPK_RN"),
 
365
SND_SOC_DAPM_OUTPUT("OUT3"),
 
366
};
 
367
 
 
368
static const struct snd_soc_dapm_widget wm8960_dapm_widgets_out3[] = {
 
369
SND_SOC_DAPM_MIXER("Mono Output Mixer", WM8960_POWER2, 1, 0,
 
370
        &wm8960_mono_out[0],
 
371
        ARRAY_SIZE(wm8960_mono_out)),
 
372
};
 
373
 
 
374
/* Represent OUT3 as a PGA so that it gets turned on with LOUT1/ROUT1 */
 
375
static const struct snd_soc_dapm_widget wm8960_dapm_widgets_capless[] = {
 
376
SND_SOC_DAPM_PGA("OUT3 VMID", WM8960_POWER2, 1, 0, NULL, 0),
 
377
};
 
378
 
 
379
static const struct snd_soc_dapm_route audio_paths[] = {
 
380
        { "Left Boost Mixer", "LINPUT1 Switch", "LINPUT1" },
 
381
        { "Left Boost Mixer", "LINPUT2 Switch", "LINPUT2" },
 
382
        { "Left Boost Mixer", "LINPUT3 Switch", "LINPUT3" },
 
383
 
 
384
        { "Left Input Mixer", "Boost Switch", "Left Boost Mixer", },
 
385
        { "Left Input Mixer", NULL, "LINPUT1", },  /* Really Boost Switch */
 
386
        { "Left Input Mixer", NULL, "LINPUT2" },
 
387
        { "Left Input Mixer", NULL, "LINPUT3" },
 
388
 
 
389
        { "Right Boost Mixer", "RINPUT1 Switch", "RINPUT1" },
 
390
        { "Right Boost Mixer", "RINPUT2 Switch", "RINPUT2" },
 
391
        { "Right Boost Mixer", "RINPUT3 Switch", "RINPUT3" },
 
392
 
 
393
        { "Right Input Mixer", "Boost Switch", "Right Boost Mixer", },
 
394
        { "Right Input Mixer", NULL, "RINPUT1", },  /* Really Boost Switch */
 
395
        { "Right Input Mixer", NULL, "RINPUT2" },
 
396
        { "Right Input Mixer", NULL, "LINPUT3" },
 
397
 
 
398
        { "Left ADC", NULL, "Left Input Mixer" },
 
399
        { "Right ADC", NULL, "Right Input Mixer" },
 
400
 
 
401
        { "Left Output Mixer", "LINPUT3 Switch", "LINPUT3" },
 
402
        { "Left Output Mixer", "Boost Bypass Switch", "Left Boost Mixer"} ,
 
403
        { "Left Output Mixer", "PCM Playback Switch", "Left DAC" },
 
404
 
 
405
        { "Right Output Mixer", "RINPUT3 Switch", "RINPUT3" },
 
406
        { "Right Output Mixer", "Boost Bypass Switch", "Right Boost Mixer" } ,
 
407
        { "Right Output Mixer", "PCM Playback Switch", "Right DAC" },
 
408
 
 
409
        { "LOUT1 PGA", NULL, "Left Output Mixer" },
 
410
        { "ROUT1 PGA", NULL, "Right Output Mixer" },
 
411
 
 
412
        { "HP_L", NULL, "LOUT1 PGA" },
 
413
        { "HP_R", NULL, "ROUT1 PGA" },
 
414
 
 
415
        { "Left Speaker PGA", NULL, "Left Output Mixer" },
 
416
        { "Right Speaker PGA", NULL, "Right Output Mixer" },
 
417
 
 
418
        { "Left Speaker Output", NULL, "Left Speaker PGA" },
 
419
        { "Right Speaker Output", NULL, "Right Speaker PGA" },
 
420
 
 
421
        { "SPK_LN", NULL, "Left Speaker Output" },
 
422
        { "SPK_LP", NULL, "Left Speaker Output" },
 
423
        { "SPK_RN", NULL, "Right Speaker Output" },
 
424
        { "SPK_RP", NULL, "Right Speaker Output" },
 
425
};
 
426
 
 
427
static const struct snd_soc_dapm_route audio_paths_out3[] = {
 
428
        { "Mono Output Mixer", "Left Switch", "Left Output Mixer" },
 
429
        { "Mono Output Mixer", "Right Switch", "Right Output Mixer" },
 
430
 
 
431
        { "OUT3", NULL, "Mono Output Mixer", }
 
432
};
 
433
 
 
434
static const struct snd_soc_dapm_route audio_paths_capless[] = {
 
435
        { "HP_L", NULL, "OUT3 VMID" },
 
436
        { "HP_R", NULL, "OUT3 VMID" },
 
437
 
 
438
        { "OUT3 VMID", NULL, "Left Output Mixer" },
 
439
        { "OUT3 VMID", NULL, "Right Output Mixer" },
 
440
};
 
441
 
 
442
static int wm8960_add_widgets(struct snd_soc_codec *codec)
 
443
{
 
444
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
445
        struct wm8960_data *pdata = &wm8960->pdata;
 
446
        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
447
        struct snd_soc_dapm_widget *w;
 
448
 
 
449
        snd_soc_dapm_new_controls(dapm, wm8960_dapm_widgets,
 
450
                                  ARRAY_SIZE(wm8960_dapm_widgets));
 
451
 
 
452
        snd_soc_dapm_add_routes(dapm, audio_paths, ARRAY_SIZE(audio_paths));
 
453
 
 
454
        /* In capless mode OUT3 is used to provide VMID for the
 
455
         * headphone outputs, otherwise it is used as a mono mixer.
 
456
         */
 
457
        if (pdata && pdata->capless) {
 
458
                snd_soc_dapm_new_controls(dapm, wm8960_dapm_widgets_capless,
 
459
                                          ARRAY_SIZE(wm8960_dapm_widgets_capless));
 
460
 
 
461
                snd_soc_dapm_add_routes(dapm, audio_paths_capless,
 
462
                                        ARRAY_SIZE(audio_paths_capless));
 
463
        } else {
 
464
                snd_soc_dapm_new_controls(dapm, wm8960_dapm_widgets_out3,
 
465
                                          ARRAY_SIZE(wm8960_dapm_widgets_out3));
 
466
 
 
467
                snd_soc_dapm_add_routes(dapm, audio_paths_out3,
 
468
                                        ARRAY_SIZE(audio_paths_out3));
 
469
        }
 
470
 
 
471
        /* We need to power up the headphone output stage out of
 
472
         * sequence for capless mode.  To save scanning the widget
 
473
         * list each time to find the desired power state do so now
 
474
         * and save the result.
 
475
         */
 
476
        list_for_each_entry(w, &codec->component.card->widgets, list) {
 
477
                if (w->dapm != &codec->dapm)
 
478
                        continue;
 
479
                if (strcmp(w->name, "LOUT1 PGA") == 0)
 
480
                        wm8960->lout1 = w;
 
481
                if (strcmp(w->name, "ROUT1 PGA") == 0)
 
482
                        wm8960->rout1 = w;
 
483
                if (strcmp(w->name, "OUT3 VMID") == 0)
 
484
                        wm8960->out3 = w;
 
485
        }
 
486
        
 
487
        return 0;
 
488
}
 
489
 
 
490
static int wm8960_set_dai_fmt(struct snd_soc_dai *codec_dai,
 
491
                unsigned int fmt)
 
492
{
 
493
        struct snd_soc_codec *codec = codec_dai->codec;
 
494
        u16 iface = 0;
 
495
 
 
496
        /* set master/slave audio interface */
 
497
        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 
498
        case SND_SOC_DAIFMT_CBM_CFM:
 
499
                iface |= 0x0040;
 
500
                break;
 
501
        case SND_SOC_DAIFMT_CBS_CFS:
 
502
                break;
 
503
        default:
 
504
                return -EINVAL;
 
505
        }
 
506
 
 
507
        /* interface format */
 
508
        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 
509
        case SND_SOC_DAIFMT_I2S:
 
510
                iface |= 0x0002;
 
511
                break;
 
512
        case SND_SOC_DAIFMT_RIGHT_J:
 
513
                break;
 
514
        case SND_SOC_DAIFMT_LEFT_J:
 
515
                iface |= 0x0001;
 
516
                break;
 
517
        case SND_SOC_DAIFMT_DSP_A:
 
518
                iface |= 0x0003;
 
519
                break;
 
520
        case SND_SOC_DAIFMT_DSP_B:
 
521
                iface |= 0x0013;
 
522
                break;
 
523
        default:
 
524
                return -EINVAL;
 
525
        }
 
526
 
 
527
        /* clock inversion */
 
528
        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 
529
        case SND_SOC_DAIFMT_NB_NF:
 
530
                break;
 
531
        case SND_SOC_DAIFMT_IB_IF:
 
532
                iface |= 0x0090;
 
533
                break;
 
534
        case SND_SOC_DAIFMT_IB_NF:
 
535
                iface |= 0x0080;
 
536
                break;
 
537
        case SND_SOC_DAIFMT_NB_IF:
 
538
                iface |= 0x0010;
 
539
                break;
 
540
        default:
 
541
                return -EINVAL;
 
542
        }
 
543
 
 
544
        /* set iface */
 
545
        snd_soc_write(codec, WM8960_IFACE1, iface);
 
546
        return 0;
 
547
}
 
548
 
 
549
static struct {
 
550
        int rate;
 
551
        unsigned int val;
 
552
} alc_rates[] = {
 
553
        { 48000, 0 },
 
554
        { 44100, 0 },
 
555
        { 32000, 1 },
 
556
        { 22050, 2 },
 
557
        { 24000, 2 },
 
558
        { 16000, 3 },
 
559
        { 11250, 4 },
 
560
        { 12000, 4 },
 
561
        {  8000, 5 },
 
562
};
 
563
 
 
564
static int wm8960_hw_params(struct snd_pcm_substream *substream,
 
565
                            struct snd_pcm_hw_params *params,
 
566
                            struct snd_soc_dai *dai)
 
567
{
 
568
        struct snd_soc_codec *codec = dai->codec;
 
569
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
570
        u16 iface = snd_soc_read(codec, WM8960_IFACE1) & 0xfff3;
 
571
        int i;
 
572
 
 
573
        /* bit size */
 
574
        switch (params_width(params)) {
 
575
        case 16:
 
576
                break;
 
577
        case 20:
 
578
                iface |= 0x0004;
 
579
                break;
 
580
        case 24:
 
581
                iface |= 0x0008;
 
582
                break;
 
583
        default:
 
584
                dev_err(codec->dev, "unsupported width %d\n",
 
585
                        params_width(params));
 
586
                return -EINVAL;
 
587
        }
 
588
 
 
589
        /* Update filters for the new rate */
 
590
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 
591
                wm8960->playback_fs = params_rate(params);
 
592
                wm8960_set_deemph(codec);
 
593
        } else {
 
594
                for (i = 0; i < ARRAY_SIZE(alc_rates); i++)
 
595
                        if (alc_rates[i].rate == params_rate(params))
 
596
                                snd_soc_update_bits(codec,
 
597
                                                    WM8960_ADDCTL3, 0x7,
 
598
                                                    alc_rates[i].val);
 
599
        }
 
600
 
 
601
        /* set iface */
 
602
        snd_soc_write(codec, WM8960_IFACE1, iface);
 
603
        return 0;
 
604
}
 
605
 
 
606
static int wm8960_mute(struct snd_soc_dai *dai, int mute)
 
607
{
 
608
        struct snd_soc_codec *codec = dai->codec;
 
609
 
 
610
        if (mute)
 
611
                snd_soc_update_bits(codec, WM8960_DACCTL1, 0x8, 0x8);
 
612
        else
 
613
                snd_soc_update_bits(codec, WM8960_DACCTL1, 0x8, 0);
 
614
        return 0;
 
615
}
 
616
 
 
617
static int wm8960_set_bias_level_out3(struct snd_soc_codec *codec,
 
618
                                      enum snd_soc_bias_level level)
 
619
{
 
620
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
621
 
 
622
        switch (level) {
 
623
        case SND_SOC_BIAS_ON:
 
624
                break;
 
625
 
 
626
        case SND_SOC_BIAS_PREPARE:
 
627
                /* Set VMID to 2x50k */
 
628
                snd_soc_update_bits(codec, WM8960_POWER1, 0x180, 0x80);
 
629
                break;
 
630
 
 
631
        case SND_SOC_BIAS_STANDBY:
 
632
                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
 
633
                        regcache_sync(wm8960->regmap);
 
634
 
 
635
                        /* Enable anti-pop features */
 
636
                        snd_soc_write(codec, WM8960_APOP1,
 
637
                                      WM8960_POBCTRL | WM8960_SOFT_ST |
 
638
                                      WM8960_BUFDCOPEN | WM8960_BUFIOEN);
 
639
 
 
640
                        /* Enable & ramp VMID at 2x50k */
 
641
                        snd_soc_update_bits(codec, WM8960_POWER1, 0x80, 0x80);
 
642
                        msleep(100);
 
643
 
 
644
                        /* Enable VREF */
 
645
                        snd_soc_update_bits(codec, WM8960_POWER1, WM8960_VREF,
 
646
                                            WM8960_VREF);
 
647
 
 
648
                        /* Disable anti-pop features */
 
649
                        snd_soc_write(codec, WM8960_APOP1, WM8960_BUFIOEN);
 
650
                }
 
651
 
 
652
                /* Set VMID to 2x250k */
 
653
                snd_soc_update_bits(codec, WM8960_POWER1, 0x180, 0x100);
 
654
                break;
 
655
 
 
656
        case SND_SOC_BIAS_OFF:
 
657
                /* Enable anti-pop features */
 
658
                snd_soc_write(codec, WM8960_APOP1,
 
659
                             WM8960_POBCTRL | WM8960_SOFT_ST |
 
660
                             WM8960_BUFDCOPEN | WM8960_BUFIOEN);
 
661
 
 
662
                /* Disable VMID and VREF, let them discharge */
 
663
                snd_soc_write(codec, WM8960_POWER1, 0);
 
664
                msleep(600);
 
665
                break;
 
666
        }
 
667
 
 
668
        codec->dapm.bias_level = level;
 
669
 
 
670
        return 0;
 
671
}
 
672
 
 
673
static int wm8960_set_bias_level_capless(struct snd_soc_codec *codec,
 
674
                                         enum snd_soc_bias_level level)
 
675
{
 
676
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
677
        int reg;
 
678
 
 
679
        switch (level) {
 
680
        case SND_SOC_BIAS_ON:
 
681
                break;
 
682
 
 
683
        case SND_SOC_BIAS_PREPARE:
 
684
                switch (codec->dapm.bias_level) {
 
685
                case SND_SOC_BIAS_STANDBY:
 
686
                        /* Enable anti pop mode */
 
687
                        snd_soc_update_bits(codec, WM8960_APOP1,
 
688
                                            WM8960_POBCTRL | WM8960_SOFT_ST |
 
689
                                            WM8960_BUFDCOPEN,
 
690
                                            WM8960_POBCTRL | WM8960_SOFT_ST |
 
691
                                            WM8960_BUFDCOPEN);
 
692
 
 
693
                        /* Enable LOUT1, ROUT1 and OUT3 if they're enabled */
 
694
                        reg = 0;
 
695
                        if (wm8960->lout1 && wm8960->lout1->power)
 
696
                                reg |= WM8960_PWR2_LOUT1;
 
697
                        if (wm8960->rout1 && wm8960->rout1->power)
 
698
                                reg |= WM8960_PWR2_ROUT1;
 
699
                        if (wm8960->out3 && wm8960->out3->power)
 
700
                                reg |= WM8960_PWR2_OUT3;
 
701
                        snd_soc_update_bits(codec, WM8960_POWER2,
 
702
                                            WM8960_PWR2_LOUT1 |
 
703
                                            WM8960_PWR2_ROUT1 |
 
704
                                            WM8960_PWR2_OUT3, reg);
 
705
 
 
706
                        /* Enable VMID at 2*50k */
 
707
                        snd_soc_update_bits(codec, WM8960_POWER1,
 
708
                                            WM8960_VMID_MASK, 0x80);
 
709
 
 
710
                        /* Ramp */
 
711
                        msleep(100);
 
712
 
 
713
                        /* Enable VREF */
 
714
                        snd_soc_update_bits(codec, WM8960_POWER1,
 
715
                                            WM8960_VREF, WM8960_VREF);
 
716
 
 
717
                        msleep(100);
 
718
                        break;
 
719
 
 
720
                case SND_SOC_BIAS_ON:
 
721
                        /* Enable anti-pop mode */
 
722
                        snd_soc_update_bits(codec, WM8960_APOP1,
 
723
                                            WM8960_POBCTRL | WM8960_SOFT_ST |
 
724
                                            WM8960_BUFDCOPEN,
 
725
                                            WM8960_POBCTRL | WM8960_SOFT_ST |
 
726
                                            WM8960_BUFDCOPEN);
 
727
 
 
728
                        /* Disable VMID and VREF */
 
729
                        snd_soc_update_bits(codec, WM8960_POWER1,
 
730
                                            WM8960_VREF | WM8960_VMID_MASK, 0);
 
731
                        break;
 
732
 
 
733
                case SND_SOC_BIAS_OFF:
 
734
                        regcache_sync(wm8960->regmap);
 
735
                        break;
 
736
                default:
 
737
                        break;
 
738
                }
 
739
                break;
 
740
 
 
741
        case SND_SOC_BIAS_STANDBY:
 
742
                switch (codec->dapm.bias_level) {
 
743
                case SND_SOC_BIAS_PREPARE:
 
744
                        /* Disable HP discharge */
 
745
                        snd_soc_update_bits(codec, WM8960_APOP2,
 
746
                                            WM8960_DISOP | WM8960_DRES_MASK,
 
747
                                            0);
 
748
 
 
749
                        /* Disable anti-pop features */
 
750
                        snd_soc_update_bits(codec, WM8960_APOP1,
 
751
                                            WM8960_POBCTRL | WM8960_SOFT_ST |
 
752
                                            WM8960_BUFDCOPEN,
 
753
                                            WM8960_POBCTRL | WM8960_SOFT_ST |
 
754
                                            WM8960_BUFDCOPEN);
 
755
                        break;
 
756
 
 
757
                default:
 
758
                        break;
 
759
                }
 
760
                break;
 
761
 
 
762
        case SND_SOC_BIAS_OFF:
 
763
                break;
 
764
        }
 
765
 
 
766
        codec->dapm.bias_level = level;
 
767
 
 
768
        return 0;
 
769
}
 
770
 
 
771
/* PLL divisors */
 
772
struct _pll_div {
 
773
        u32 pre_div:1;
 
774
        u32 n:4;
 
775
        u32 k:24;
 
776
};
 
777
 
 
778
/* The size in bits of the pll divide multiplied by 10
 
779
 * to allow rounding later */
 
780
#define FIXED_PLL_SIZE ((1 << 24) * 10)
 
781
 
 
782
static int pll_factors(unsigned int source, unsigned int target,
 
783
                       struct _pll_div *pll_div)
 
784
{
 
785
        unsigned long long Kpart;
 
786
        unsigned int K, Ndiv, Nmod;
 
787
 
 
788
        pr_debug("WM8960 PLL: setting %dHz->%dHz\n", source, target);
 
789
 
 
790
        /* Scale up target to PLL operating frequency */
 
791
        target *= 4;
 
792
 
 
793
        Ndiv = target / source;
 
794
        if (Ndiv < 6) {
 
795
                source >>= 1;
 
796
                pll_div->pre_div = 1;
 
797
                Ndiv = target / source;
 
798
        } else
 
799
                pll_div->pre_div = 0;
 
800
 
 
801
        if ((Ndiv < 6) || (Ndiv > 12)) {
 
802
                pr_err("WM8960 PLL: Unsupported N=%d\n", Ndiv);
 
803
                return -EINVAL;
 
804
        }
 
805
 
 
806
        pll_div->n = Ndiv;
 
807
        Nmod = target % source;
 
808
        Kpart = FIXED_PLL_SIZE * (long long)Nmod;
 
809
 
 
810
        do_div(Kpart, source);
 
811
 
 
812
        K = Kpart & 0xFFFFFFFF;
 
813
 
 
814
        /* Check if we need to round */
 
815
        if ((K % 10) >= 5)
 
816
                K += 5;
 
817
 
 
818
        /* Move down to proper range now rounding is done */
 
819
        K /= 10;
 
820
 
 
821
        pll_div->k = K;
 
822
 
 
823
        pr_debug("WM8960 PLL: N=%x K=%x pre_div=%d\n",
 
824
                 pll_div->n, pll_div->k, pll_div->pre_div);
 
825
 
 
826
        return 0;
 
827
}
 
828
 
 
829
static int wm8960_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
 
830
                int source, unsigned int freq_in, unsigned int freq_out)
 
831
{
 
832
        struct snd_soc_codec *codec = codec_dai->codec;
 
833
        u16 reg;
 
834
        static struct _pll_div pll_div;
 
835
        int ret;
 
836
 
 
837
        if (freq_in && freq_out) {
 
838
                ret = pll_factors(freq_in, freq_out, &pll_div);
 
839
                if (ret != 0)
 
840
                        return ret;
 
841
        }
 
842
 
 
843
        /* Disable the PLL: even if we are changing the frequency the
 
844
         * PLL needs to be disabled while we do so. */
 
845
        snd_soc_update_bits(codec, WM8960_CLOCK1, 0x1, 0);
 
846
        snd_soc_update_bits(codec, WM8960_POWER2, 0x1, 0);
 
847
 
 
848
        if (!freq_in || !freq_out)
 
849
                return 0;
 
850
 
 
851
        reg = snd_soc_read(codec, WM8960_PLL1) & ~0x3f;
 
852
        reg |= pll_div.pre_div << 4;
 
853
        reg |= pll_div.n;
 
854
 
 
855
        if (pll_div.k) {
 
856
                reg |= 0x20;
 
857
 
 
858
                snd_soc_write(codec, WM8960_PLL2, (pll_div.k >> 16) & 0xff);
 
859
                snd_soc_write(codec, WM8960_PLL3, (pll_div.k >> 8) & 0xff);
 
860
                snd_soc_write(codec, WM8960_PLL4, pll_div.k & 0xff);
 
861
        }
 
862
        snd_soc_write(codec, WM8960_PLL1, reg);
 
863
 
 
864
        /* Turn it on */
 
865
        snd_soc_update_bits(codec, WM8960_POWER2, 0x1, 0x1);
 
866
        msleep(250);
 
867
        snd_soc_update_bits(codec, WM8960_CLOCK1, 0x1, 0x1);
 
868
 
 
869
        return 0;
 
870
}
 
871
 
 
872
static int wm8960_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
 
873
                int div_id, int div)
 
874
{
 
875
        struct snd_soc_codec *codec = codec_dai->codec;
 
876
        u16 reg;
 
877
 
 
878
        switch (div_id) {
 
879
        case WM8960_SYSCLKDIV:
 
880
                reg = snd_soc_read(codec, WM8960_CLOCK1) & 0x1f9;
 
881
                snd_soc_write(codec, WM8960_CLOCK1, reg | div);
 
882
                break;
 
883
        case WM8960_DACDIV:
 
884
                reg = snd_soc_read(codec, WM8960_CLOCK1) & 0x1c7;
 
885
                snd_soc_write(codec, WM8960_CLOCK1, reg | div);
 
886
                break;
 
887
        case WM8960_OPCLKDIV:
 
888
                reg = snd_soc_read(codec, WM8960_PLL1) & 0x03f;
 
889
                snd_soc_write(codec, WM8960_PLL1, reg | div);
 
890
                break;
 
891
        case WM8960_DCLKDIV:
 
892
                reg = snd_soc_read(codec, WM8960_CLOCK2) & 0x03f;
 
893
                snd_soc_write(codec, WM8960_CLOCK2, reg | div);
 
894
                break;
 
895
        case WM8960_TOCLKSEL:
 
896
                reg = snd_soc_read(codec, WM8960_ADDCTL1) & 0x1fd;
 
897
                snd_soc_write(codec, WM8960_ADDCTL1, reg | div);
 
898
                break;
 
899
        default:
 
900
                return -EINVAL;
 
901
        }
 
902
 
 
903
        return 0;
 
904
}
 
905
 
 
906
static int wm8960_set_bias_level(struct snd_soc_codec *codec,
 
907
                                 enum snd_soc_bias_level level)
 
908
{
 
909
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
910
 
 
911
        return wm8960->set_bias_level(codec, level);
 
912
}
 
913
 
 
914
#define WM8960_RATES SNDRV_PCM_RATE_8000_48000
 
915
 
 
916
#define WM8960_FORMATS \
 
917
        (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
 
918
        SNDRV_PCM_FMTBIT_S24_LE)
 
919
 
 
920
static const struct snd_soc_dai_ops wm8960_dai_ops = {
 
921
        .hw_params = wm8960_hw_params,
 
922
        .digital_mute = wm8960_mute,
 
923
        .set_fmt = wm8960_set_dai_fmt,
 
924
        .set_clkdiv = wm8960_set_dai_clkdiv,
 
925
        .set_pll = wm8960_set_dai_pll,
 
926
};
 
927
 
 
928
static struct snd_soc_dai_driver wm8960_dai = {
 
929
        .name = "wm8960-hifi",
 
930
        .playback = {
 
931
                .stream_name = "Playback",
 
932
                .channels_min = 1,
 
933
                .channels_max = 2,
 
934
                .rates = WM8960_RATES,
 
935
                .formats = WM8960_FORMATS,},
 
936
        .capture = {
 
937
                .stream_name = "Capture",
 
938
                .channels_min = 1,
 
939
                .channels_max = 2,
 
940
                .rates = WM8960_RATES,
 
941
                .formats = WM8960_FORMATS,},
 
942
        .ops = &wm8960_dai_ops,
 
943
        .symmetric_rates = 1,
 
944
};
 
945
 
 
946
static int wm8960_probe(struct snd_soc_codec *codec)
 
947
{
 
948
        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
 
949
        struct wm8960_data *pdata = &wm8960->pdata;
 
950
 
 
951
        if (pdata->capless)
 
952
                wm8960->set_bias_level = wm8960_set_bias_level_capless;
 
953
        else
 
954
                wm8960->set_bias_level = wm8960_set_bias_level_out3;
 
955
 
 
956
        snd_soc_add_codec_controls(codec, wm8960_snd_controls,
 
957
                                     ARRAY_SIZE(wm8960_snd_controls));
 
958
        wm8960_add_widgets(codec);
 
959
 
 
960
        return 0;
 
961
}
 
962
 
 
963
static struct snd_soc_codec_driver soc_codec_dev_wm8960 = {
 
964
        .probe =        wm8960_probe,
 
965
        .set_bias_level = wm8960_set_bias_level,
 
966
        .suspend_bias_off = true,
 
967
};
 
968
 
 
969
static const struct regmap_config wm8960_regmap = {
 
970
        .reg_bits = 7,
 
971
        .val_bits = 9,
 
972
        .max_register = WM8960_PLL4,
 
973
 
 
974
        .reg_defaults = wm8960_reg_defaults,
 
975
        .num_reg_defaults = ARRAY_SIZE(wm8960_reg_defaults),
 
976
        .cache_type = REGCACHE_RBTREE,
 
977
 
 
978
        .volatile_reg = wm8960_volatile,
 
979
};
 
980
 
 
981
static void wm8960_set_pdata_from_of(struct i2c_client *i2c,
 
982
                                struct wm8960_data *pdata)
 
983
{
 
984
        const struct device_node *np = i2c->dev.of_node;
 
985
 
 
986
        if (of_property_read_bool(np, "wlf,capless"))
 
987
                pdata->capless = true;
 
988
 
 
989
        if (of_property_read_bool(np, "wlf,shared-lrclk"))
 
990
                pdata->shared_lrclk = true;
 
991
}
 
992
 
 
993
static int wm8960_i2c_probe(struct i2c_client *i2c,
 
994
                            const struct i2c_device_id *id)
 
995
{
 
996
        struct wm8960_data *pdata = dev_get_platdata(&i2c->dev);
 
997
        struct wm8960_priv *wm8960;
 
998
        int ret;
 
999
 
 
1000
        wm8960 = devm_kzalloc(&i2c->dev, sizeof(struct wm8960_priv),
 
1001
                              GFP_KERNEL);
 
1002
        if (wm8960 == NULL)
 
1003
                return -ENOMEM;
 
1004
 
 
1005
        wm8960->regmap = devm_regmap_init_i2c(i2c, &wm8960_regmap);
 
1006
        if (IS_ERR(wm8960->regmap))
 
1007
                return PTR_ERR(wm8960->regmap);
 
1008
 
 
1009
        if (pdata)
 
1010
                memcpy(&wm8960->pdata, pdata, sizeof(struct wm8960_data));
 
1011
        else if (i2c->dev.of_node)
 
1012
                wm8960_set_pdata_from_of(i2c, &wm8960->pdata);
 
1013
 
 
1014
        ret = wm8960_reset(wm8960->regmap);
 
1015
        if (ret != 0) {
 
1016
                dev_err(&i2c->dev, "Failed to issue reset\n");
 
1017
                return ret;
 
1018
        }
 
1019
 
 
1020
        if (wm8960->pdata.shared_lrclk) {
 
1021
                ret = regmap_update_bits(wm8960->regmap, WM8960_ADDCTL2,
 
1022
                                         0x4, 0x4);
 
1023
                if (ret != 0) {
 
1024
                        dev_err(&i2c->dev, "Failed to enable LRCM: %d\n",
 
1025
                                ret);
 
1026
                        return ret;
 
1027
                }
 
1028
        }
 
1029
 
 
1030
        /* Latch the update bits */
 
1031
        regmap_update_bits(wm8960->regmap, WM8960_LINVOL, 0x100, 0x100);
 
1032
        regmap_update_bits(wm8960->regmap, WM8960_RINVOL, 0x100, 0x100);
 
1033
        regmap_update_bits(wm8960->regmap, WM8960_LADC, 0x100, 0x100);
 
1034
        regmap_update_bits(wm8960->regmap, WM8960_RADC, 0x100, 0x100);
 
1035
        regmap_update_bits(wm8960->regmap, WM8960_LDAC, 0x100, 0x100);
 
1036
        regmap_update_bits(wm8960->regmap, WM8960_RDAC, 0x100, 0x100);
 
1037
        regmap_update_bits(wm8960->regmap, WM8960_LOUT1, 0x100, 0x100);
 
1038
        regmap_update_bits(wm8960->regmap, WM8960_ROUT1, 0x100, 0x100);
 
1039
        regmap_update_bits(wm8960->regmap, WM8960_LOUT2, 0x100, 0x100);
 
1040
        regmap_update_bits(wm8960->regmap, WM8960_ROUT2, 0x100, 0x100);
 
1041
 
 
1042
        i2c_set_clientdata(i2c, wm8960);
 
1043
 
 
1044
        ret = snd_soc_register_codec(&i2c->dev,
 
1045
                        &soc_codec_dev_wm8960, &wm8960_dai, 1);
 
1046
 
 
1047
        return ret;
 
1048
}
 
1049
 
 
1050
static int wm8960_i2c_remove(struct i2c_client *client)
 
1051
{
 
1052
        snd_soc_unregister_codec(&client->dev);
 
1053
        return 0;
 
1054
}
 
1055
 
 
1056
static const struct i2c_device_id wm8960_i2c_id[] = {
 
1057
        { "wm8960", 0 },
 
1058
        { }
 
1059
};
 
1060
MODULE_DEVICE_TABLE(i2c, wm8960_i2c_id);
 
1061
 
 
1062
static const struct of_device_id wm8960_of_match[] = {
 
1063
       { .compatible = "wlf,wm8960", },
 
1064
       { }
 
1065
};
 
1066
MODULE_DEVICE_TABLE(of, wm8960_of_match);
 
1067
 
 
1068
static struct i2c_driver wm8960_i2c_driver = {
 
1069
        .driver = {
 
1070
                .name = "wm8960",
 
1071
                .owner = THIS_MODULE,
 
1072
                .of_match_table = wm8960_of_match,
 
1073
        },
 
1074
        .probe =    wm8960_i2c_probe,
 
1075
        .remove =   wm8960_i2c_remove,
 
1076
        .id_table = wm8960_i2c_id,
 
1077
};
 
1078
 
 
1079
module_i2c_driver(wm8960_i2c_driver);
 
1080
 
 
1081
MODULE_DESCRIPTION("ASoC WM8960 driver");
 
1082
MODULE_AUTHOR("Liam Girdwood");
 
1083
MODULE_LICENSE("GPL");