Merge linux-3.10.67 into dev-kernel-3.10
[linux-3.10.git] / sound / soc / codecs / max98090.c
1 /*
2  * max98090.c -- MAX98090 ALSA SoC Audio driver
3  *
4  * Copyright 2011-2012 Maxim Integrated Products
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10
11 #include <linux/delay.h>
12 #include <linux/i2c.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <sound/pcm.h>
16 #include <sound/pcm_params.h>
17 #include <sound/soc.h>
18 #include <sound/tlv.h>
19 #include <sound/max98090.h>
20 #include <linux/gpio.h>
21 #include "max98090.h"
22
23 #include <linux/version.h>
24
25 #ifndef __devexit
26 #define __devexit
27 #endif
28 #ifndef __devexit_p
29 #define __devexit_p(x)  (x)
30 #endif
31
32 #define DEBUG
33 #define EXTMIC_METHOD
34 #define EXTMIC_METHOD_TEST
35
36 static const u8 max98090_reg_def[M98090_REG_CNT] = {
37         0x00, /* 00 Software Reset */
38         0x00, /* 01 Device Status */
39         0x00, /* 02 Jack Status */
40         0x04, /* 03 Interrupt Masks */
41         0x00, /* 04 System Clock Quick */
42         0x00, /* 05 Sample Rate Quick */
43         0x00, /* 06 DAI Interface Quick */
44         0x00, /* 07 DAC Path Quick */
45         0x00, /* 08 Mic/Direct to ADC Quick */
46         0x00, /* 09 Line to ADC Quick */
47         0x00, /* 0A Analog Mic Loop Quick */
48         0x00, /* 0B Analog Line Loop Quick */
49         0x00, /* 0C Reserved */
50         0x00, /* 0D Input Config */
51         0x1B, /* 0E Line Input Level */
52         0x00, /* 0F Line Config */
53
54         0x14, /* 10 Mic1 Input Level */
55         0x14, /* 11 Mic2 Input Level */
56         0x00, /* 12 Mic Bias Voltage */
57         0x00, /* 13 Digital Mic Config */
58         0x00, /* 14 Digital Mic Mode */
59         0x00, /* 15 Left ADC Mixer */
60         0x00, /* 16 Right ADC Mixer */
61         0x03, /* 17 Left ADC Level */
62         0x03, /* 18 Right ADC Level */
63         0x00, /* 19 ADC Biquad Level */
64         0x00, /* 1A ADC Sidetone */
65         0x00, /* 1B System Clock */
66         0x00, /* 1C Clock Mode */
67         0x00, /* 1D Any Clock 1 */
68         0x00, /* 1E Any Clock 2 */
69         0x00, /* 1F Any Clock 3 */
70
71         0x00, /* 20 Any Clock 4 */
72         0x00, /* 21 Master Mode */
73         0x00, /* 22 Interface Format */
74         0x00, /* 23 TDM Format 1*/
75         0x00, /* 24 TDM Format 2*/
76         0x00, /* 25 I/O Configuration */
77         0x80, /* 26 Filter Config */
78         0x00, /* 27 DAI Playback Level */
79         0x00, /* 28 EQ Playback Level */
80         0x00, /* 29 Left HP Mixer */
81         0x00, /* 2A Right HP Mixer */
82         0x00, /* 2B HP Control */
83         0x1A, /* 2C Left HP Volume */
84         0x1A, /* 2D Right HP Volume */
85         0x00, /* 2E Left Spk Mixer */
86         0x00, /* 2F Right Spk Mixer */
87
88         0x00, /* 30 Spk Control */
89         0x2C, /* 31 Left Spk Volume */
90         0x2C, /* 32 Right Spk Volume */
91         0x00, /* 33 ALC Timing */
92         0x00, /* 34 ALC Compressor */
93         0x00, /* 35 ALC Expander */
94         0x00, /* 36 ALC Gain */
95         0x00, /* 37 Rcv/Line OutL Mixer */
96         0x00, /* 38 Rcv/Line OutL Control */
97         0x15, /* 39 Rcv/Line OutL Volume */
98         0x00, /* 3A Line OutR Mixer */
99         0x00, /* 3B Line OutR Control */
100         0x15, /* 3C Line OutR Volume */
101         0x00, /* 3D Jack Detect */
102         0x00, /* 3E Input Enable */
103         0x00, /* 3F Output Enable */
104
105         0x00, /* 40 Level Control */
106         0x00, /* 41 DSP Filter Enable */
107         0x00, /* 42 Bias Control */
108         0x00, /* 43 DAC Control */
109         0x06, /* 44 ADC Control */
110         0x00, /* 45 Device Shutdown */
111         0x00, /* 46 Equalizer Band 1 Coefficient B0 */
112         0x00, /* 47 Equalizer Band 1 Coefficient B0 */
113         0x00, /* 48 Equalizer Band 1 Coefficient B0 */
114         0x00, /* 49 Equalizer Band 1 Coefficient B1 */
115         0x00, /* 4A Equalizer Band 1 Coefficient B1 */
116         0x00, /* 4B Equalizer Band 1 Coefficient B1 */
117         0x00, /* 4C Equalizer Band 1 Coefficient B2 */
118         0x00, /* 4D Equalizer Band 1 Coefficient B2 */
119         0x00, /* 4E Equalizer Band 1 Coefficient B2 */
120         0x00, /* 4F Equalizer Band 1 Coefficient A1 */
121
122         0x00, /* 50 Equalizer Band 1 Coefficient A1 */
123         0x00, /* 51 Equalizer Band 1 Coefficient A1 */
124         0x00, /* 52 Equalizer Band 1 Coefficient A2 */
125         0x00, /* 53 Equalizer Band 1 Coefficient A2 */
126         0x00, /* 54 Equalizer Band 1 Coefficient A2 */
127         0x00, /* 55 Equalizer Band 2 Coefficient B0 */
128         0x00, /* 56 Equalizer Band 2 Coefficient B0 */
129         0x00, /* 57 Equalizer Band 2 Coefficient B0 */
130         0x00, /* 58 Equalizer Band 2 Coefficient B1 */
131         0x00, /* 59 Equalizer Band 2 Coefficient B1 */
132         0x00, /* 5A Equalizer Band 2 Coefficient B1 */
133         0x00, /* 5B Equalizer Band 2 Coefficient B2 */
134         0x00, /* 5C Equalizer Band 2 Coefficient B2 */
135         0x00, /* 5D Equalizer Band 2 Coefficient B2 */
136         0x00, /* 5E Equalizer Band 2 Coefficient A1 */
137         0x00, /* 5F Equalizer Band 2 Coefficient A1 */
138
139         0x00, /* 60 Equalizer Band 2 Coefficient A1 */
140         0x00, /* 61 Equalizer Band 2 Coefficient A2 */
141         0x00, /* 62 Equalizer Band 2 Coefficient A2 */
142         0x00, /* 63 Equalizer Band 2 Coefficient A2 */
143         0x00, /* 64 Equalizer Band 3 Coefficient B0 */
144         0x00, /* 65 Equalizer Band 3 Coefficient B0 */
145         0x00, /* 66 Equalizer Band 3 Coefficient B0 */
146         0x00, /* 67 Equalizer Band 3 Coefficient B1 */
147         0x00, /* 68 Equalizer Band 3 Coefficient B1 */
148         0x00, /* 69 Equalizer Band 3 Coefficient B1 */
149         0x00, /* 6A Equalizer Band 3 Coefficient B2 */
150         0x00, /* 6B Equalizer Band 3 Coefficient B2 */
151         0x00, /* 6C Equalizer Band 3 Coefficient B2 */
152         0x00, /* 6D Equalizer Band 3 Coefficient A1 */
153         0x00, /* 6E Equalizer Band 3 Coefficient A1 */
154         0x00, /* 6F Equalizer Band 3 Coefficient A1 */
155
156         0x00, /* 70 Equalizer Band 3 Coefficient A2 */
157         0x00, /* 71 Equalizer Band 3 Coefficient A2 */
158         0x00, /* 72 Equalizer Band 3 Coefficient A2 */
159         0x00, /* 73 Equalizer Band 4 Coefficient B0 */
160         0x00, /* 74 Equalizer Band 4 Coefficient B0 */
161         0x00, /* 75 Equalizer Band 4 Coefficient B0 */
162         0x00, /* 76 Equalizer Band 4 Coefficient B1 */
163         0x00, /* 77 Equalizer Band 4 Coefficient B1 */
164         0x00, /* 78 Equalizer Band 4 Coefficient B1 */
165         0x00, /* 79 Equalizer Band 4 Coefficient B2 */
166         0x00, /* 7A Equalizer Band 4 Coefficient B2 */
167         0x00, /* 7B Equalizer Band 4 Coefficient B2 */
168         0x00, /* 7C Equalizer Band 4 Coefficient A1 */
169         0x00, /* 7D Equalizer Band 4 Coefficient A1 */
170         0x00, /* 7E Equalizer Band 4 Coefficient A1 */
171         0x00, /* 7F Equalizer Band 4 Coefficient A2 */
172
173         0x00, /* 80 Equalizer Band 4 Coefficient A2 */
174         0x00, /* 81 Equalizer Band 4 Coefficient A2 */
175         0x00, /* 82 Equalizer Band 5 Coefficient B0 */
176         0x00, /* 83 Equalizer Band 5 Coefficient B0 */
177         0x00, /* 84 Equalizer Band 5 Coefficient B0 */
178         0x00, /* 85 Equalizer Band 5 Coefficient B1 */
179         0x00, /* 86 Equalizer Band 5 Coefficient B1 */
180         0x00, /* 87 Equalizer Band 5 Coefficient B1 */
181         0x00, /* 88 Equalizer Band 5 Coefficient B2 */
182         0x00, /* 89 Equalizer Band 5 Coefficient B2 */
183         0x00, /* 8A Equalizer Band 5 Coefficient B2 */
184         0x00, /* 8B Equalizer Band 5 Coefficient A1 */
185         0x00, /* 8C Equalizer Band 5 Coefficient A1 */
186         0x00, /* 8D Equalizer Band 5 Coefficient A1 */
187         0x00, /* 8E Equalizer Band 5 Coefficient A2 */
188         0x00, /* 8F Equalizer Band 5 Coefficient A2 */
189
190         0x00, /* 90 Equalizer Band 5 Coefficient A2 */
191         0x00, /* 91 Equalizer Band 6 Coefficient B0 */
192         0x00, /* 92 Equalizer Band 6 Coefficient B0 */
193         0x00, /* 93 Equalizer Band 6 Coefficient B0 */
194         0x00, /* 94 Equalizer Band 6 Coefficient B1 */
195         0x00, /* 95 Equalizer Band 6 Coefficient B1 */
196         0x00, /* 96 Equalizer Band 6 Coefficient B1 */
197         0x00, /* 97 Equalizer Band 6 Coefficient B2 */
198         0x00, /* 98 Equalizer Band 6 Coefficient B2 */
199         0x00, /* 99 Equalizer Band 6 Coefficient B2 */
200         0x00, /* 9A Equalizer Band 6 Coefficient A1 */
201         0x00, /* 9B Equalizer Band 6 Coefficient A1 */
202         0x00, /* 9C Equalizer Band 6 Coefficient A1 */
203         0x00, /* 9D Equalizer Band 6 Coefficient A2 */
204         0x00, /* 9E Equalizer Band 6 Coefficient A2 */
205         0x00, /* 9F Equalizer Band 6 Coefficient A2 */
206
207         0x00, /* A0 Equalizer Band 7 Coefficient B0 */
208         0x00, /* A1 Equalizer Band 7 Coefficient B0 */
209         0x00, /* A2 Equalizer Band 7 Coefficient B0 */
210         0x00, /* A3 Equalizer Band 7 Coefficient B1 */
211         0x00, /* A4 Equalizer Band 7 Coefficient B1 */
212         0x00, /* A5 Equalizer Band 7 Coefficient B1 */
213         0x00, /* A6 Equalizer Band 7 Coefficient B2 */
214         0x00, /* A7 Equalizer Band 7 Coefficient B2 */
215         0x00, /* A8 Equalizer Band 7 Coefficient B2 */
216         0x00, /* A9 Equalizer Band 7 Coefficient A1 */
217         0x00, /* AA Equalizer Band 7 Coefficient A1 */
218         0x00, /* AB Equalizer Band 7 Coefficient A1 */
219         0x00, /* AC Equalizer Band 7 Coefficient A2 */
220         0x00, /* AD Equalizer Band 7 Coefficient A2 */
221         0x00, /* AE Equalizer Band 7 Coefficient A2 */
222         0x00, /* AF ADC Biquad Coefficient B0 */
223
224         0x00, /* B0 ADC Biquad Coefficient B0 */
225         0x00, /* B1 ADC Biquad Coefficient B0 */
226         0x00, /* B2 ADC Biquad Coefficient B1 */
227         0x00, /* B3 ADC Biquad Coefficient B1 */
228         0x00, /* B4 ADC Biquad Coefficient B1 */
229         0x00, /* B5 ADC Biquad Coefficient B2 */
230         0x00, /* B6 ADC Biquad Coefficient B2 */
231         0x00, /* B7 ADC Biquad Coefficient B2 */
232         0x00, /* B8 ADC Biquad Coefficient A1 */
233         0x00, /* B9 ADC Biquad Coefficient A1 */
234         0x00, /* BA ADC Biquad Coefficient A1 */
235         0x00, /* BB ADC Biquad Coefficient A2 */
236         0x00, /* BC ADC Biquad Coefficient A2 */
237         0x00, /* BD ADC Biquad Coefficient A2 */
238         0x00, /* BE */
239         0x00, /* BF */
240
241         0x00, /* C0 */
242         0x00, /* C1 */
243         0x00, /* C2 */
244         0x00, /* C3 */
245         0x00, /* C4 */
246         0x00, /* C5 */
247         0x00, /* C6 */
248         0x00, /* C7 */
249         0x00, /* C8 */
250         0x00, /* C9 */
251         0x00, /* CA */
252         0x00, /* CB */
253         0x00, /* CC */
254         0x00, /* CD */
255         0x00, /* CE */
256         0x00, /* CF */
257
258         0x00, /* D0 */
259         0x00, /* D1 */
260         0x00, /* D2 */
261         0x00, /* D3 */
262         0x00, /* D4 */
263         0x00, /* D5 */
264         0x00, /* D6 */
265         0x00, /* D7 */
266         0x00, /* D8 */
267         0x00, /* D9 */
268         0x00, /* DA */
269         0x00, /* DB */
270         0x00, /* DC */
271         0x00, /* DD */
272         0x00, /* DE */
273         0x00, /* DF */
274
275         0x00, /* E0 */
276         0x00, /* E1 */
277         0x00, /* E2 */
278         0x00, /* E3 */
279         0x00, /* E4 */
280         0x00, /* E5 */
281         0x00, /* E6 */
282         0x00, /* E7 */
283         0x00, /* E8 */
284         0x00, /* E9 */
285         0x00, /* EA */
286         0x00, /* EB */
287         0x00, /* EC */
288         0x00, /* ED */
289         0x00, /* EE */
290         0x00, /* EF */
291
292         0x00, /* F0 */
293         0x00, /* F1 */
294         0x00, /* F2 */
295         0x00, /* F3 */
296         0x00, /* F4 */
297         0x00, /* F5 */
298         0x00, /* F6 */
299         0x00, /* F7 */
300         0x00, /* F8 */
301         0x00, /* F9 */
302         0x00, /* FA */
303         0x00, /* FB */
304         0x00, /* FC */
305         0x00, /* FD */
306         0x00, /* FE */
307         0x00, /* FF rev id */
308 };
309
310 static struct {
311         u8 read;
312         u8 write;
313         u8 vol;
314 } max98090_reg_access[M98090_REG_CNT] = {
315         { 0x00, 0xFF, 0x00 }, /* 00 */
316         { 0xFF, 0x00, 0xFF }, /* 01 */
317         { 0xFF, 0x00, 0xFF }, /* 02 */
318         { 0xFF, 0xFF, 0x00 }, /* 03 */
319         { 0x00, 0xFF, 0x00 }, /* 04 */
320         { 0x00, 0xFF, 0x00 }, /* 05 */
321         { 0x00, 0xFF, 0x00 }, /* 06 */
322         { 0x00, 0xFF, 0x00 }, /* 07 */
323         { 0x00, 0xFF, 0x00 }, /* 08 */
324         { 0x00, 0xFF, 0x00 }, /* 09 */
325         { 0x00, 0xFF, 0x00 }, /* 0A */
326         { 0x00, 0xFF, 0x00 }, /* 0B */
327         { 0xFF, 0xFF, 0x00 }, /* 0C */
328         { 0xFF, 0xFF, 0x00 }, /* 0D */
329         { 0xFF, 0xFF, 0x00 }, /* 0E */
330         { 0xFF, 0xFF, 0x00 }, /* 0F */
331
332         { 0xFF, 0xFF, 0x00 }, /* 10 */
333         { 0xFF, 0xFF, 0x00 }, /* 11 */
334         { 0xFF, 0xFF, 0x00 }, /* 12 */
335         { 0xFF, 0xFF, 0x00 }, /* 13 */
336         { 0xFF, 0xFF, 0x00 }, /* 14 */
337         { 0xFF, 0xFF, 0x00 }, /* 15 */
338         { 0xFF, 0xFF, 0x00 }, /* 16 */
339         { 0xFF, 0xFF, 0x00 }, /* 17 */
340         { 0xFF, 0xFF, 0x00 }, /* 18 */
341         { 0xFF, 0xFF, 0x00 }, /* 19 */
342         { 0xFF, 0xFF, 0x00 }, /* 1A */
343         { 0xFF, 0xFF, 0x00 }, /* 1B */
344         { 0xFF, 0xFF, 0x00 }, /* 1C */
345         { 0xFF, 0xFF, 0x00 }, /* 1D */
346         { 0xFF, 0xFF, 0x00 }, /* 1E */
347         { 0xFF, 0xFF, 0x00 }, /* 1F */
348
349         { 0xFF, 0xFF, 0x00 }, /* 20 */
350         { 0xFF, 0xFF, 0x00 }, /* 21 */
351         { 0xFF, 0xFF, 0x00 }, /* 22 */
352         { 0xFF, 0xFF, 0x00 }, /* 23 */
353         { 0xFF, 0xFF, 0x00 }, /* 24 */
354         { 0xFF, 0xFF, 0x00 }, /* 25 */
355         { 0xFF, 0xFF, 0x00 }, /* 26 */
356         { 0xFF, 0xFF, 0x00 }, /* 27 */
357         { 0xFF, 0xFF, 0x00 }, /* 28 */
358         { 0xFF, 0xFF, 0x00 }, /* 29 */
359         { 0xFF, 0xFF, 0x00 }, /* 2A */
360         { 0xFF, 0xFF, 0x00 }, /* 2B */
361         { 0xFF, 0xFF, 0x00 }, /* 2C */
362         { 0xFF, 0xFF, 0x00 }, /* 2D */
363         { 0xFF, 0xFF, 0x00 }, /* 2E */
364         { 0xFF, 0xFF, 0x00 }, /* 2F */
365
366         { 0xFF, 0xFF, 0x00 }, /* 30 */
367         { 0xFF, 0xFF, 0x00 }, /* 31 */
368         { 0xFF, 0xFF, 0x00 }, /* 32 */
369         { 0xFF, 0xFF, 0x00 }, /* 33 */
370         { 0xFF, 0xFF, 0x00 }, /* 34 */
371         { 0xFF, 0xFF, 0x00 }, /* 35 */
372         { 0xFF, 0xFF, 0x00 }, /* 36 */
373         { 0xFF, 0xFF, 0x00 }, /* 37 */
374         { 0xFF, 0xFF, 0x00 }, /* 38 */
375         { 0xFF, 0xFF, 0x00 }, /* 39 */
376         { 0xFF, 0xFF, 0x00 }, /* 3A */
377         { 0xFF, 0xFF, 0x00 }, /* 3B */
378         { 0xFF, 0xFF, 0x00 }, /* 3C */
379         { 0xFF, 0xFF, 0x00 }, /* 3D */
380         { 0xFF, 0xFF, 0x00 }, /* 3E */
381         { 0xFF, 0xFF, 0x00 }, /* 3F */
382
383         { 0xFF, 0xFF, 0x00 }, /* 40 */
384         { 0xFF, 0xFF, 0x00 }, /* 41 */
385         { 0xFF, 0xFF, 0x00 }, /* 42 */
386         { 0xFF, 0xFF, 0x00 }, /* 43 */
387         { 0xFF, 0xFF, 0x00 }, /* 44 */
388         { 0xFF, 0xFF, 0x00 }, /* 45 */
389         { 0xFF, 0xFF, 0x00 }, /* 46 */
390         { 0xFF, 0xFF, 0x00 }, /* 47 */
391         { 0xFF, 0xFF, 0x00 }, /* 48 */
392         { 0xFF, 0xFF, 0x00 }, /* 49 */
393         { 0xFF, 0xFF, 0x00 }, /* 4A */
394         { 0xFF, 0xFF, 0x00 }, /* 4B */
395         { 0xFF, 0xFF, 0x00 }, /* 4C */
396         { 0xFF, 0xFF, 0x00 }, /* 4D */
397         { 0xFF, 0xFF, 0x00 }, /* 4E */
398         { 0xFF, 0xFF, 0x00 }, /* 4F */
399
400         { 0xFF, 0xFF, 0x00 }, /* 50 */
401         { 0xFF, 0xFF, 0x00 }, /* 51 */
402         { 0xFF, 0xFF, 0x00 }, /* 52 */
403         { 0xFF, 0xFF, 0x00 }, /* 53 */
404         { 0xFF, 0xFF, 0x00 }, /* 54 */
405         { 0xFF, 0xFF, 0x00 }, /* 55 */
406         { 0xFF, 0xFF, 0x00 }, /* 56 */
407         { 0xFF, 0xFF, 0x00 }, /* 57 */
408         { 0xFF, 0xFF, 0x00 }, /* 58 */
409         { 0xFF, 0xFF, 0x00 }, /* 59 */
410         { 0xFF, 0xFF, 0x00 }, /* 5A */
411         { 0xFF, 0xFF, 0x00 }, /* 5B */
412         { 0xFF, 0xFF, 0x00 }, /* 5C */
413         { 0xFF, 0xFF, 0x00 }, /* 5D */
414         { 0xFF, 0xFF, 0x00 }, /* 5E */
415         { 0xFF, 0xFF, 0x00 }, /* 5F */
416
417         { 0xFF, 0xFF, 0x00 }, /* 60 */
418         { 0xFF, 0xFF, 0x00 }, /* 61 */
419         { 0xFF, 0xFF, 0x00 }, /* 62 */
420         { 0xFF, 0xFF, 0x00 }, /* 63 */
421         { 0xFF, 0xFF, 0x00 }, /* 64 */
422         { 0xFF, 0xFF, 0x00 }, /* 65 */
423         { 0xFF, 0xFF, 0x00 }, /* 66 */
424         { 0xFF, 0xFF, 0x00 }, /* 67 */
425         { 0xFF, 0xFF, 0x00 }, /* 68 */
426         { 0xFF, 0xFF, 0x00 }, /* 69 */
427         { 0xFF, 0xFF, 0x00 }, /* 6A */
428         { 0xFF, 0xFF, 0x00 }, /* 6B */
429         { 0xFF, 0xFF, 0x00 }, /* 6C */
430         { 0xFF, 0xFF, 0x00 }, /* 6D */
431         { 0xFF, 0xFF, 0x00 }, /* 6E */
432         { 0xFF, 0xFF, 0x00 }, /* 6F */
433
434         { 0xFF, 0xFF, 0x00 }, /* 70 */
435         { 0xFF, 0xFF, 0x00 }, /* 71 */
436         { 0xFF, 0xFF, 0x00 }, /* 72 */
437         { 0xFF, 0xFF, 0x00 }, /* 73 */
438         { 0xFF, 0xFF, 0x00 }, /* 74 */
439         { 0xFF, 0xFF, 0x00 }, /* 75 */
440         { 0xFF, 0xFF, 0x00 }, /* 76 */
441         { 0xFF, 0xFF, 0x00 }, /* 77 */
442         { 0xFF, 0xFF, 0x00 }, /* 78 */
443         { 0xFF, 0xFF, 0x00 }, /* 79 */
444         { 0xFF, 0xFF, 0x00 }, /* 7A */
445         { 0xFF, 0xFF, 0x00 }, /* 7B */
446         { 0xFF, 0xFF, 0x00 }, /* 7C */
447         { 0xFF, 0xFF, 0x00 }, /* 7D */
448         { 0xFF, 0xFF, 0x00 }, /* 7E */
449         { 0xFF, 0xFF, 0x00 }, /* 7F */
450
451         { 0xFF, 0xFF, 0x00 }, /* 80 */
452         { 0xFF, 0xFF, 0x00 }, /* 81 */
453         { 0xFF, 0xFF, 0x00 }, /* 82 */
454         { 0xFF, 0xFF, 0x00 }, /* 83 */
455         { 0xFF, 0xFF, 0x00 }, /* 84 */
456         { 0xFF, 0xFF, 0x00 }, /* 85 */
457         { 0xFF, 0xFF, 0x00 }, /* 86 */
458         { 0xFF, 0xFF, 0x00 }, /* 87 */
459         { 0xFF, 0xFF, 0x00 }, /* 88 */
460         { 0xFF, 0xFF, 0x00 }, /* 89 */
461         { 0xFF, 0xFF, 0x00 }, /* 8A */
462         { 0xFF, 0xFF, 0x00 }, /* 8B */
463         { 0xFF, 0xFF, 0x00 }, /* 8C */
464         { 0xFF, 0xFF, 0x00 }, /* 8D */
465         { 0xFF, 0xFF, 0x00 }, /* 8E */
466         { 0xFF, 0xFF, 0x00 }, /* 8F */
467
468         { 0xFF, 0xFF, 0x00 }, /* 90 */
469         { 0xFF, 0xFF, 0x00 }, /* 91 */
470         { 0xFF, 0xFF, 0x00 }, /* 92 */
471         { 0xFF, 0xFF, 0x00 }, /* 93 */
472         { 0xFF, 0xFF, 0x00 }, /* 94 */
473         { 0xFF, 0xFF, 0x00 }, /* 95 */
474         { 0xFF, 0xFF, 0x00 }, /* 96 */
475         { 0xFF, 0xFF, 0x00 }, /* 97 */
476         { 0xFF, 0xFF, 0x00 }, /* 98 */
477         { 0xFF, 0xFF, 0x00 }, /* 99 */
478         { 0xFF, 0xFF, 0x00 }, /* 9A */
479         { 0xFF, 0xFF, 0x00 }, /* 9B */
480         { 0xFF, 0xFF, 0x00 }, /* 9C */
481         { 0xFF, 0xFF, 0x00 }, /* 9D */
482         { 0xFF, 0xFF, 0x00 }, /* 9E */
483         { 0xFF, 0xFF, 0x00 }, /* 9F */
484
485         { 0xFF, 0xFF, 0x00 }, /* A0 */
486         { 0xFF, 0xFF, 0x00 }, /* A1 */
487         { 0xFF, 0xFF, 0x00 }, /* A2 */
488         { 0xFF, 0xFF, 0x00 }, /* A3 */
489         { 0xFF, 0xFF, 0x00 }, /* A4 */
490         { 0xFF, 0xFF, 0x00 }, /* A5 */
491         { 0xFF, 0xFF, 0x00 }, /* A6 */
492         { 0xFF, 0xFF, 0x00 }, /* A7 */
493         { 0xFF, 0xFF, 0x00 }, /* A8 */
494         { 0xFF, 0xFF, 0x00 }, /* A9 */
495         { 0xFF, 0xFF, 0x00 }, /* AA */
496         { 0xFF, 0xFF, 0x00 }, /* AB */
497         { 0xFF, 0xFF, 0x00 }, /* AC */
498         { 0xFF, 0xFF, 0x00 }, /* AD */
499         { 0xFF, 0xFF, 0x00 }, /* AE */
500         { 0xFF, 0xFF, 0x00 }, /* AF */
501
502         { 0xFF, 0xFF, 0x00 }, /* B0 */
503         { 0xFF, 0xFF, 0x00 }, /* B1 */
504         { 0xFF, 0xFF, 0x00 }, /* B2 */
505         { 0xFF, 0xFF, 0x00 }, /* B3 */
506         { 0xFF, 0xFF, 0x00 }, /* B4 */
507         { 0xFF, 0xFF, 0x00 }, /* B5 */
508         { 0xFF, 0xFF, 0x00 }, /* B6 */
509         { 0xFF, 0xFF, 0x00 }, /* B7 */
510         { 0xFF, 0xFF, 0x00 }, /* B8 */
511         { 0xFF, 0xFF, 0x00 }, /* B9 */
512         { 0xFF, 0xFF, 0x00 }, /* BA */
513         { 0xFF, 0xFF, 0x00 }, /* BB */
514         { 0xFF, 0xFF, 0x00 }, /* BC */
515         { 0xFF, 0xFF, 0x00 }, /* BD */
516         { 0x00, 0x00, 0x00 }, /* BE */
517         { 0x00, 0x00, 0x00 }, /* BF */
518
519         { 0x00, 0x00, 0x00 }, /* C0 */
520         { 0x00, 0x00, 0x00 }, /* C1 */
521         { 0x00, 0x00, 0x00 }, /* C2 */
522         { 0x00, 0x00, 0x00 }, /* C3 */
523         { 0x00, 0x00, 0x00 }, /* C4 */
524         { 0x00, 0x00, 0x00 }, /* C5 */
525         { 0x00, 0x00, 0x00 }, /* C6 */
526         { 0x00, 0x00, 0x00 }, /* C7 */
527         { 0x00, 0x00, 0x00 }, /* C8 */
528         { 0x00, 0x00, 0x00 }, /* C9 */
529         { 0x00, 0x00, 0x00 }, /* CA */
530         { 0x00, 0x00, 0x00 }, /* CB */
531         { 0x00, 0x00, 0x00 }, /* CC */
532         { 0x00, 0x00, 0x00 }, /* CD */
533         { 0x00, 0x00, 0x00 }, /* CE */
534         { 0x00, 0x00, 0x00 }, /* CF */
535
536         { 0x00, 0x00, 0x00 }, /* D0 */
537         { 0x00, 0x00, 0x00 }, /* D1 */
538         { 0x00, 0x00, 0x00 }, /* D2 */
539         { 0x00, 0x00, 0x00 }, /* D3 */
540         { 0x00, 0x00, 0x00 }, /* D4 */
541         { 0x00, 0x00, 0x00 }, /* D5 */
542         { 0x00, 0x00, 0x00 }, /* D6 */
543         { 0x00, 0x00, 0x00 }, /* D7 */
544         { 0x00, 0x00, 0x00 }, /* D8 */
545         { 0x00, 0x00, 0x00 }, /* D9 */
546         { 0x00, 0x00, 0x00 }, /* DA */
547         { 0x00, 0x00, 0x00 }, /* DB */
548         { 0x00, 0x00, 0x00 }, /* DC */
549         { 0x00, 0x00, 0x00 }, /* DD */
550         { 0x00, 0x00, 0x00 }, /* DE */
551         { 0x00, 0x00, 0x00 }, /* DF */
552
553         { 0x00, 0x00, 0x00 }, /* E0 */
554         { 0x00, 0x00, 0x00 }, /* E1 */
555         { 0x00, 0x00, 0x00 }, /* E2 */
556         { 0x00, 0x00, 0x00 }, /* E3 */
557         { 0x00, 0x00, 0x00 }, /* E4 */
558         { 0x00, 0x00, 0x00 }, /* E5 */
559         { 0x00, 0x00, 0x00 }, /* E6 */
560         { 0x00, 0x00, 0x00 }, /* E7 */
561         { 0x00, 0x00, 0x00 }, /* E8 */
562         { 0x00, 0x00, 0x00 }, /* E9 */
563         { 0x00, 0x00, 0x00 }, /* EA */
564         { 0x00, 0x00, 0x00 }, /* EB */
565         { 0x00, 0x00, 0x00 }, /* EC */
566         { 0x00, 0x00, 0x00 }, /* ED */
567         { 0x00, 0x00, 0x00 }, /* EE */
568         { 0x00, 0x00, 0x00 }, /* EF */
569
570         { 0x00, 0x00, 0x00 }, /* F0 */
571         { 0x00, 0x00, 0x00 }, /* F1 */
572         { 0x00, 0x00, 0x00 }, /* F2 */
573         { 0x00, 0x00, 0x00 }, /* F3 */
574         { 0x00, 0x00, 0x00 }, /* F4 */
575         { 0x00, 0x00, 0x00 }, /* F5 */
576         { 0x00, 0x00, 0x00 }, /* F6 */
577         { 0x00, 0x00, 0x00 }, /* F7 */
578         { 0x00, 0x00, 0x00 }, /* F8 */
579         { 0x00, 0x00, 0x00 }, /* F9 */
580         { 0x00, 0x00, 0x00 }, /* FA */
581         { 0x00, 0x00, 0x00 }, /* FB */
582         { 0x00, 0x00, 0x00 }, /* FC */
583         { 0x00, 0x00, 0x00 }, /* FD */
584         { 0x00, 0x00, 0x00 }, /* FE */
585         { 0xFF, 0x00, 0xFF }, /* FF */
586 };
587
588 static int max98090_volatile_register(struct snd_soc_codec *codec,
589         unsigned int reg)
590 {
591         if (max98090_reg_access[reg].vol)
592                 return 1;
593         else
594                 return 0;
595 }
596
597 static int max98090_readable(struct snd_soc_codec *codec, unsigned int reg)
598 {
599         if (reg >= M98090_REG_CNT)
600                 return 0;
601         return max98090_reg_access[reg].read != 0;
602 }
603
604 static int max98090_reset(struct snd_soc_codec *codec)
605 {
606         int ret;
607
608         /* Reset the codec by writing to this write-only reset register */
609         ret = snd_soc_write(codec, M98090_REG_00_SW_RESET,
610                 M98090_SWRESET_MASK);
611         if (ret < 0) {
612                 dev_err(codec->dev, "Failed to reset codec: %d\n", ret);
613                 return ret;
614         }
615
616         msleep(20);
617         return ret;
618 }
619
620 static const unsigned int max98090_micboost_tlv[] = {
621         TLV_DB_RANGE_HEAD(2),
622         0, 1, TLV_DB_SCALE_ITEM(0, 2000, 0),
623         2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0),
624 };
625
626 static const DECLARE_TLV_DB_SCALE(max98090_mic_tlv, 0, 100, 0);
627
628 static const unsigned int max98090_lin_tlv[] = {
629         TLV_DB_RANGE_HEAD(2),
630         0, 3, TLV_DB_SCALE_ITEM(-600, 300, 0),
631         4, 5, TLV_DB_SCALE_ITEM(1400, 600, 0),
632 };
633
634 static const DECLARE_TLV_DB_SCALE(max98090_adcboost_tlv, 0, 600, 0);
635 static const DECLARE_TLV_DB_SCALE(max98090_adc_tlv, -1200, 100, 0);
636
637 static const DECLARE_TLV_DB_SCALE(max98090_dvg_tlv, 0, 600, 0);
638 static const DECLARE_TLV_DB_SCALE(max98090_dv_tlv, -1500, 100, 0);
639
640 static const DECLARE_TLV_DB_SCALE(max98090_sidetone_tlv, -6050, 200, 0);
641
642 static const DECLARE_TLV_DB_SCALE(max98090_alc_tlv, -1500, 100, 0);
643 static const DECLARE_TLV_DB_SCALE(max98090_alcmakeup_tlv, 0, 100, 0);
644 static const DECLARE_TLV_DB_SCALE(max98090_alccomp_tlv, -3100, 100, 0);
645 static const DECLARE_TLV_DB_SCALE(max98090_alcexp_tlv, -6600, 100, 0);
646
647 static const unsigned int max98090_mixout_tlv[] = {
648         TLV_DB_RANGE_HEAD(2),
649         0, 1, TLV_DB_SCALE_ITEM(-1200, 250, 0),
650         2, 3, TLV_DB_SCALE_ITEM(-600, 600, 0),
651 };
652
653 static const unsigned int max98090_hp_tlv[] = {
654         TLV_DB_RANGE_HEAD(5),
655         0, 6, TLV_DB_SCALE_ITEM(-6700, 400, 0),
656         7, 14, TLV_DB_SCALE_ITEM(-4000, 300, 0),
657         15, 21, TLV_DB_SCALE_ITEM(-1700, 200, 0),
658         22, 27, TLV_DB_SCALE_ITEM(-400, 100, 0),
659         28, 31, TLV_DB_SCALE_ITEM(150, 50, 0),
660 };
661
662 static const unsigned int max98090_spk_tlv[] = {
663         TLV_DB_RANGE_HEAD(5),
664         0, 4, TLV_DB_SCALE_ITEM(-4800, 400, 0),
665         5, 10, TLV_DB_SCALE_ITEM(-2900, 300, 0),
666         11, 14, TLV_DB_SCALE_ITEM(-1200, 200, 0),
667         15, 29, TLV_DB_SCALE_ITEM(-500, 100, 0),
668         30, 39, TLV_DB_SCALE_ITEM(950, 50, 0),
669 };
670
671 static const unsigned int max98090_rcv_lout_tlv[] = {
672         TLV_DB_RANGE_HEAD(5),
673         0, 6, TLV_DB_SCALE_ITEM(-6200, 400, 0),
674         7, 14, TLV_DB_SCALE_ITEM(-3500, 300, 0),
675         15, 21, TLV_DB_SCALE_ITEM(-1200, 200, 0),
676         22, 27, TLV_DB_SCALE_ITEM(100, 100, 0),
677         28, 31, TLV_DB_SCALE_ITEM(650, 50, 0),
678 };
679
680 static int max98090_extmic_mux_set(struct snd_kcontrol *kcontrol,
681                                 struct snd_ctl_elem_value *ucontrol)
682 {
683         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
684         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
685         unsigned int sel = ucontrol->value.integer.value[0];
686         unsigned int val = snd_soc_read(codec, M98090_REG_0F_CFG_LINE);
687
688         val = (val & M98090_EXTMIC_MASK) >> M98090_EXTMIC_SHIFT;
689
690         max98090->extmic_mux = sel;
691
692         /* Setting a channel is only valid if it is already On */
693         if ((val == 1) || (val == 2)) {
694                 sel = sel + 1;
695         } else {
696                 /* Write what was already there */
697                 sel = val;
698         }
699
700         snd_soc_update_bits(codec, M98090_REG_0F_CFG_LINE,
701                 M98090_EXTMIC_MASK,
702                 sel << M98090_EXTMIC_SHIFT);
703
704         return 0;
705 }
706
707 static int max98090_extmic_mux_get(struct snd_kcontrol *kcontrol,
708                                 struct snd_ctl_elem_value *ucontrol)
709 {
710         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
711         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
712         unsigned int val = snd_soc_read(codec, M98090_REG_0F_CFG_LINE);
713
714         val = (val & M98090_EXTMIC_MASK) >> M98090_EXTMIC_SHIFT;
715
716         if ((val == 1) || (val == 2)) {
717                 /* If on, return the channel */
718                 val = val - 1;
719                 max98090->extmic_mux = val;
720         } else {
721                 /* If off, return last stored value */
722                 val = max98090->extmic_mux;
723         }
724
725         ucontrol->value.integer.value[0] = val;
726         return 0;
727 }
728
729 static int max98090_mic1pre_volume_set(struct snd_kcontrol *kcontrol,
730                                 struct snd_ctl_elem_value *ucontrol)
731 {
732         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
733         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
734         unsigned int sel = ucontrol->value.integer.value[0];
735         unsigned int val = snd_soc_read(codec, M98090_REG_10_LVL_MIC1);
736
737         val = (val & M98090_MIC_PA1EN_MASK) >> M98090_MIC_PA1EN_SHIFT;
738
739         max98090->mic1pre = sel;
740
741         /* Setting a volume is only valid if it is already On */
742         if (val >= 1) {
743                 sel = sel + 1;
744         } else {
745                 /* Write what was already there */
746                 sel = val;
747         }
748
749         snd_soc_update_bits(codec, M98090_REG_10_LVL_MIC1,
750                 M98090_MIC_PA1EN_MASK,
751                 sel << M98090_MIC_PA1EN_SHIFT);
752
753         return 0;
754 }
755
756 static int max98090_mic1pre_volume_get(struct snd_kcontrol *kcontrol,
757                                 struct snd_ctl_elem_value *ucontrol)
758 {
759         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
760         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
761         unsigned int val = snd_soc_read(codec, M98090_REG_10_LVL_MIC1);
762
763         val = (val & M98090_MIC_PA1EN_MASK) >> M98090_MIC_PA1EN_SHIFT;
764
765         if (val >= 1) {
766                 /* If on, return the volume */
767                 val = val - 1;
768                 max98090->mic1pre = val;
769         } else {
770                 /* If off, return last stored value */
771                 val = max98090->mic1pre;
772         }
773
774         ucontrol->value.integer.value[0] = val;
775         return 0;
776 }
777
778 static int max98090_mic2pre_volume_set(struct snd_kcontrol *kcontrol,
779                                 struct snd_ctl_elem_value *ucontrol)
780 {
781         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
782         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
783         unsigned int sel = ucontrol->value.integer.value[0];
784         unsigned int val = snd_soc_read(codec, M98090_REG_11_LVL_MIC2);
785
786         val = (val & M98090_MIC_PA2EN_MASK) >> M98090_MIC_PA2EN_SHIFT;
787
788         max98090->mic2pre = sel;
789
790         /* Setting a volume is only valid if it is already On */
791         if (val >= 1) {
792                 sel = sel + 1;
793         } else {
794                 /* Write what was already there */
795                 sel = val;
796         }
797
798         snd_soc_update_bits(codec, M98090_REG_11_LVL_MIC2,
799                 M98090_MIC_PA2EN_MASK,
800                 sel << M98090_MIC_PA2EN_SHIFT);
801
802         return 0;
803 }
804
805 static int max98090_mic2pre_volume_get(struct snd_kcontrol *kcontrol,
806                                 struct snd_ctl_elem_value *ucontrol)
807 {
808         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
809         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
810         unsigned int val = snd_soc_read(codec, M98090_REG_11_LVL_MIC2);
811
812         val = (val & M98090_MIC_PA2EN_MASK) >> M98090_MIC_PA2EN_SHIFT;
813
814         if (val >= 1) {
815                 /* If on, return the volume */
816                 val = val - 1;
817                 max98090->mic2pre = val;
818         } else {
819                 /* If off, return last stored value */
820                 val = max98090->mic2pre;
821         }
822
823         ucontrol->value.integer.value[0] = val;
824         return 0;
825 }
826
827 static int max98090_linea_set(struct snd_kcontrol *kcontrol,
828                                 struct snd_ctl_elem_value *ucontrol)
829 {
830         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
831         unsigned int sel = ucontrol->value.integer.value[0];
832
833         sel = 7 - min(sel + 2, (unsigned int)7);
834         snd_soc_update_bits(codec, M98090_REG_0E_LVL_LINE,
835                 M98090_LINAPGA_MASK,
836                 sel << M98090_LINAPGA_SHIFT);
837
838         return 0;
839 }
840
841 static int max98090_linea_get(struct snd_kcontrol *kcontrol,
842                                 struct snd_ctl_elem_value *ucontrol)
843 {
844         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
845         unsigned int val = snd_soc_read(codec, M98090_REG_0E_LVL_LINE);
846
847         val = (val & M98090_LINAPGA_MASK) >> M98090_LINAPGA_SHIFT;
848         val = 7 - min(val + 2, (unsigned int)7);
849
850         ucontrol->value.integer.value[0] = val;
851         return 0;
852 }
853
854 static int max98090_lineb_set(struct snd_kcontrol *kcontrol,
855                                 struct snd_ctl_elem_value *ucontrol)
856 {
857         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
858         unsigned int sel = ucontrol->value.integer.value[0];
859
860         sel = 7 - min(sel + 2, (unsigned int)7);
861         snd_soc_update_bits(codec, M98090_REG_0E_LVL_LINE,
862                 M98090_LINBPGA_MASK,
863                 sel << M98090_LINBPGA_SHIFT);
864
865         return 0;
866 }
867
868 static int max98090_lineb_get(struct snd_kcontrol *kcontrol,
869                                 struct snd_ctl_elem_value *ucontrol)
870 {
871         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
872         unsigned int val = snd_soc_read(codec, M98090_REG_0E_LVL_LINE);
873
874         val = (val & M98090_LINBPGA_MASK) >> M98090_LINBPGA_SHIFT;
875         val = 7 - min(val + 2, (unsigned int)7);
876
877         ucontrol->value.integer.value[0] = val;
878         return 0;
879 }
880
881 static int max98090_sidetone_volume_set(struct snd_kcontrol *kcontrol,
882                                 struct snd_ctl_elem_value *ucontrol)
883 {
884         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
885         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
886         unsigned int sel = ucontrol->value.integer.value[0];
887         unsigned int val = snd_soc_read(codec, M98090_REG_1A_LVL_SIDETONE);
888
889         val = (val & M98090_DVST_MASK) >> M98090_DVST_SHIFT;
890
891         max98090->sidetone = sel;
892
893         /* Setting a volume is only valid if it is already On */
894         if (val >= 1) {
895                 sel = 31 - sel;
896         } else {
897                 /* Write what was already there */
898                 sel = val;
899         }
900
901         snd_soc_update_bits(codec, M98090_REG_1A_LVL_SIDETONE,
902                 M98090_DVST_MASK,
903                 sel << M98090_DVST_SHIFT);
904
905         return 0;
906 }
907
908 static int max98090_sidetone_volume_get(struct snd_kcontrol *kcontrol,
909                                 struct snd_ctl_elem_value *ucontrol)
910 {
911         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
912         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
913         unsigned int val = snd_soc_read(codec, M98090_REG_1A_LVL_SIDETONE);
914
915         val = (val & M98090_DVST_MASK) >> M98090_DVST_SHIFT;
916
917         if (val >= 1) {
918                 /* If on, return the volume */
919                 val = 31 - val;
920                 max98090->sidetone = val;
921         } else {
922                 /* If off, return last stored value */
923                 val = max98090->sidetone;
924         }
925
926         ucontrol->value.integer.value[0] = val;
927         return 0;
928 }
929
930 static int max98090_spkl_set(struct snd_kcontrol *kcontrol,
931                                 struct snd_ctl_elem_value *ucontrol)
932 {
933         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
934         unsigned int sel = ucontrol->value.integer.value[0];
935
936         sel = min_t(unsigned int, sel, 39) + 24;
937
938         snd_soc_update_bits(codec, M98090_REG_31_LVL_SPK_LEFT,
939                 M98090_SPVOLL_MASK,
940                 sel << M98090_SPVOLL_SHIFT);
941
942         return 0;
943 }
944
945 static int max98090_spkr_set(struct snd_kcontrol *kcontrol,
946                                 struct snd_ctl_elem_value *ucontrol)
947 {
948         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
949         unsigned int sel = ucontrol->value.integer.value[0];
950
951         sel = min_t(unsigned int, sel, 39) + 24;
952
953         snd_soc_update_bits(codec, M98090_REG_32_LVL_SPK_RIGHT,
954                 M98090_SPVOLR_MASK,
955                 sel << M98090_SPVOLR_SHIFT);
956
957         return 0;
958 }
959
960 static int max98090_spkl_get(struct snd_kcontrol *kcontrol,
961                                 struct snd_ctl_elem_value *ucontrol)
962 {
963         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
964         unsigned int val = snd_soc_read(codec, M98090_REG_31_LVL_SPK_LEFT);
965
966         val = (val & M98090_SPVOLL_MASK) >> M98090_SPVOLL_SHIFT;
967         val = max_t(unsigned int, val, 24) - 24;
968
969         ucontrol->value.integer.value[0] = val;
970
971         return 0;
972 }
973
974 static int max98090_spkr_get(struct snd_kcontrol *kcontrol,
975                                 struct snd_ctl_elem_value *ucontrol)
976 {
977         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
978         unsigned int val = snd_soc_read(codec, M98090_REG_32_LVL_SPK_RIGHT);
979
980         val = (val & M98090_SPVOLR_MASK) >> M98090_SPVOLR_SHIFT;
981         val = max_t(unsigned int, val, 24) - 24;
982
983         ucontrol->value.integer.value[0] = val;
984
985         return 0;
986 }
987
988 static const char * const max98090_mbvsel_text[] = {
989         "2.2V", "2.4V", "2.55V", "2.8V" };
990
991 static const struct soc_enum max98090_mbvsel_enum =
992         SOC_ENUM_SINGLE(M98090_REG_12_MIC_BIAS, M98090_MBVSEL_SHIFT,
993                 ARRAY_SIZE(max98090_mbvsel_text), max98090_mbvsel_text);
994
995 static const char * const max98090_freq_text[] = {
996         "Disable", "Reserved1", "Reserved2", "Reserved3",
997         "Reserved4", "Reserved5", "Reserved6", "Reserved7",
998         "12MHz_8kHz", "12MHz_16kHz", "13MHz_8kHz", "13MHz_16kHz",
999         "16MHz_8kHz", "16MHz_16kHz", "19.2MHz_8kHz", "19.2MHz_16kHz" };
1000
1001 static const struct soc_enum max98090_freq_enum =
1002         SOC_ENUM_SINGLE(M98090_REG_1C_CLOCK_MODE, M98090_CLK_FREQ1_SHIFT,
1003                 ARRAY_SIZE(max98090_freq_text), max98090_freq_text);
1004
1005 static const char * const max98090_fsw_text[] = { "Bit", "Word" };
1006
1007 static const struct soc_enum max98090_fsw_enum =
1008         SOC_ENUM_SINGLE(M98090_REG_23_DAI_TDM_CONTROL, M98090_DAI_FSW_SHIFT,
1009                 ARRAY_SIZE(max98090_fsw_text), max98090_fsw_text);
1010
1011 static const char * const max98090_bsel_text[] = {
1012         "Disable", "32xfs", "48xfs", "64xfs",
1013         "fPCLK/2", "fPCLK/4", "fPCLK/8", "fPCLK/16" };
1014
1015 static const struct soc_enum max98090_bsel_enum =
1016         SOC_ENUM_SINGLE(M98090_REG_21_CLOCK_MAS_MODE, M98090_CLK_BSEL_SHIFT,
1017                 ARRAY_SIZE(max98090_bsel_text), max98090_bsel_text);
1018
1019 static const char * const max98090_micclk_text[] = {
1020         "fPCLK/2", "fPCLK/3", "fPCLK/4", "fPCLK/5",
1021         "fPCLK/6", "fPCLK/8" };
1022
1023 static const struct soc_enum max98090_micclk_enum =
1024         SOC_ENUM_SINGLE(M98090_REG_13_MIC_CFG1, M98090_MICCLK_SHIFT,
1025                 ARRAY_SIZE(max98090_micclk_text), max98090_micclk_text);
1026
1027 static const struct soc_enum max98090_dmic34clk_enum =
1028         SOC_ENUM_SINGLE(M98090_REG_C2_SAMPLE_RATE, M98090_DMIC34_SRDIV_SHIFT,
1029                 ARRAY_SIZE(max98090_micclk_text), max98090_micclk_text);
1030
1031 static const char * const max98090_dmicfreq_text[] = {
1032         "fDMICKCLK<3.5MHz", "3.5MHz<=fDMICKCLK<4.5MHz",
1033         "4.5MHz<=fDMICKCLK" };
1034
1035 static const struct soc_enum max98090_dmicfreq_enum =
1036         SOC_ENUM_SINGLE(M98090_REG_14_MIC_CFG2, M98090_DMIC_FREQ_SHIFT,
1037                 ARRAY_SIZE(max98090_dmicfreq_text), max98090_dmicfreq_text);
1038
1039 static const char * const max98090_extmic_mux_text[] = { "MIC1", "MIC2" };
1040
1041 static const struct soc_enum max98090_extmic_mux_enum =
1042         SOC_ENUM_SINGLE(M98090_REG_0F_CFG_LINE, M98090_EXTMIC_SHIFT,
1043                 ARRAY_SIZE(max98090_extmic_mux_text),
1044                 max98090_extmic_mux_text);
1045
1046 static const char * const max98090_mixg_text[] = { "Normal", "6dB" };
1047
1048 static const struct soc_enum max98090_mixg135_enum =
1049         SOC_ENUM_SINGLE(M98090_REG_0E_LVL_LINE, M98090_MIXG135_SHIFT,
1050                 ARRAY_SIZE(max98090_mixg_text), max98090_mixg_text);
1051
1052 static const struct soc_enum max98090_mixg246_enum =
1053         SOC_ENUM_SINGLE(M98090_REG_0E_LVL_LINE, M98090_MIXT246_SHIFT,
1054                 ARRAY_SIZE(max98090_mixg_text), max98090_mixg_text);
1055
1056 static const char * const max98090_osr128_text[] = { "64*fs", "128*fs" };
1057
1058 static const struct soc_enum max98090_osr128_enum =
1059         SOC_ENUM_SINGLE(M98090_REG_44_ADC_CFG, M98090_ADC_OSR128_SHIFT,
1060                 ARRAY_SIZE(max98090_osr128_text), max98090_osr128_text);
1061
1062 static const char * const max98090_enableddisabled_text[] = {
1063         "Disabled", "Enabled" };
1064 static const char * const max98090_enableddisabled_inv_text[] = {
1065         "Enabled", "Disabled" };
1066 /* Note: Inverted Logic (0 = Enabled) */
1067
1068 static const struct soc_enum max98090_eqclpn_enum =
1069         SOC_ENUM_SINGLE(M98090_REG_28_DAI_LVL_EQ, M98090_DAI_LVL_EQCLPN_SHIFT,
1070                 ARRAY_SIZE(max98090_enableddisabled_inv_text),
1071                 max98090_enableddisabled_inv_text);
1072
1073 static const struct soc_enum max98090_sdien_enum =
1074         SOC_ENUM_SINGLE(M98090_REG_25_DAI_IOCFG, M98090_DAI_SDIEN_SHIFT,
1075                 ARRAY_SIZE(max98090_enableddisabled_text),
1076                 max98090_enableddisabled_text);
1077
1078 static const struct soc_enum max98090_sdoen_enum =
1079         SOC_ENUM_SINGLE(M98090_REG_25_DAI_IOCFG, M98090_DAI_SDOEN_SHIFT,
1080                 ARRAY_SIZE(max98090_enableddisabled_text),
1081                 max98090_enableddisabled_text);
1082
1083 static const struct soc_enum max98090_hizoff_enum =
1084         SOC_ENUM_SINGLE(M98090_REG_25_DAI_IOCFG, M98090_DAI_HIZOFF_SHIFT,
1085                 ARRAY_SIZE(max98090_enableddisabled_inv_text),
1086                 max98090_enableddisabled_inv_text);
1087
1088 static const char * const max98090_fltr_mode_text[] = { "Voice", "Music" };
1089
1090 static const struct soc_enum max98090_filter_mode_enum =
1091         SOC_ENUM_SINGLE(M98090_REG_26_DAI_FILTERS, M98090_DAI_FLT_MODE_SHIFT,
1092                 ARRAY_SIZE(max98090_fltr_mode_text), max98090_fltr_mode_text);
1093
1094 static const struct soc_enum max98090_filter_dmic34mode_enum =
1095         SOC_ENUM_SINGLE(M98090_REG_26_DAI_FILTERS,
1096                 M98090_DAI_FLT_DMIC34MODE_SHIFT,
1097                 ARRAY_SIZE(max98090_fltr_mode_text), max98090_fltr_mode_text);
1098
1099 static const char * const max98090_dsts_text[] = {
1100         "None", "Left", "Right", "Left and Right" };
1101
1102 static const struct soc_enum max98090_dsts_enum =
1103         SOC_ENUM_SINGLE(M98090_REG_1A_LVL_SIDETONE, M98090_DSTS_SHIFT,
1104                 ARRAY_SIZE(max98090_dsts_text), max98090_dsts_text);
1105
1106 static const char * const max98090_alcatk_text[] = {
1107         "0.5ms", "1ms", "5ms", "10ms",
1108         "25ms", "50ms", "100ms", "200ms" };
1109
1110 static const struct soc_enum max98090_alcatk_enum =
1111         SOC_ENUM_SINGLE(M98090_REG_33_ALC_TIMING, M98090_ALCATK_SHIFT,
1112                 ARRAY_SIZE(max98090_alcatk_text), max98090_alcatk_text);
1113
1114 static const char * const max98090_alcrls_text[] =      {
1115         "8s", "4s", "2s", "1s",
1116         "0.5s", "0.25s", "0.125s", "0.0625s" };
1117
1118 static const struct soc_enum max98090_alcrls_enum =
1119         SOC_ENUM_SINGLE(M98090_REG_33_ALC_TIMING, M98090_ALCRLS_SHIFT,
1120                 ARRAY_SIZE(max98090_alcrls_text), max98090_alcrls_text);
1121
1122 static const char * const max98090_alccmp_text[] = {
1123         "1:1", "1:1.5", "1:2", "1:4", "1:INF" };
1124
1125 static const struct soc_enum max98090_alccmp_enum =
1126         SOC_ENUM_SINGLE(M98090_REG_34_ALC_CMPR, M98090_ALCCMP_SHIFT,
1127                 ARRAY_SIZE(max98090_alccmp_text), max98090_alccmp_text);
1128
1129 static const char * const max98090_alcexp_text[] = { "1:1", "2:1", "3:1" };
1130
1131 static const struct soc_enum max98090_alcexp_enum =
1132         SOC_ENUM_SINGLE(M98090_REG_35_ALC_EXP, M98090_ALCEXP_SHIFT,
1133                 ARRAY_SIZE(max98090_alcexp_text), max98090_alcexp_text);
1134
1135 static const struct soc_enum max98090_zdenn_enum =
1136         SOC_ENUM_SINGLE(M98090_REG_40_CFG_LVL, M98090_ZDENN_SHIFT,
1137                 ARRAY_SIZE(max98090_enableddisabled_inv_text),
1138                 max98090_enableddisabled_inv_text);
1139
1140 static const struct soc_enum max98090_vs2enn_enum =
1141         SOC_ENUM_SINGLE(M98090_REG_40_CFG_LVL, M98090_VS2ENN_SHIFT,
1142                 ARRAY_SIZE(max98090_enableddisabled_inv_text),
1143                 max98090_enableddisabled_inv_text);
1144
1145 static const struct soc_enum max98090_vsenn_enum =
1146         SOC_ENUM_SINGLE(M98090_REG_40_CFG_LVL, M98090_VSENN_SHIFT,
1147                 ARRAY_SIZE(max98090_enableddisabled_inv_text),
1148                 max98090_enableddisabled_inv_text);
1149
1150 static const struct snd_kcontrol_new max98090_snd_controls[] = {
1151         SOC_ENUM("MIC Bias Config", max98090_mbvsel_enum),
1152         SOC_SINGLE("MIC Bias VCM Bandgap", M98090_REG_42_BIAS_CNTL,
1153                 M98090_VCM_MODE_SHIFT, M98090_VCM_MODE_NUM - 1, 0),
1154         SOC_ENUM("CLK Exact Integer Freq Config", max98090_freq_enum),
1155
1156         SOC_SINGLE("CLK Use MI", M98090_REG_1C_CLOCK_MODE,
1157                 M98090_CLK_USE_M1_SHIFT, M98090_CLK_USE_M1_NUM - 1, 0),
1158         SOC_SINGLE("CLK NI HI", M98090_REG_1D_CLOCK_DAI1_NI_HI,
1159                 M98090_CLK_NI_HI_SHIFT, M98090_CLK_NI_HI_NUM - 1, 0),
1160         SOC_SINGLE("CLK NI LO", M98090_REG_1E_CLOCK_DAI2_NI_LO,
1161                 M98090_CLK_NI_LO_SHIFT, M98090_CLK_NI_LO_NUM - 1, 0),
1162         SOC_SINGLE("CLK MI HI", M98090_REG_1F_CLOCK_DAI3_MI_HI,
1163                 M98090_CLK_MI_HI_SHIFT, M98090_CLK_MI_HI_NUM - 1, 0),
1164         SOC_SINGLE("CLK MI LO", M98090_REG_20_CLOCK_DAI4_MI_LO,
1165                 M98090_CLK_MI_LO_SHIFT, M98090_CLK_MI_LO_NUM - 1, 0),
1166
1167         SOC_SINGLE("DAI Input Data Word Size",
1168                 M98090_REG_22_DAI_INTERFACE_FORMAT,
1169                 M98090_DAI_WS_SHIFT, M98090_DAI_WS_NUM - 1, 0),
1170
1171         SOC_ENUM("DAI Frame Sync Pulse Width", max98090_fsw_enum),
1172         SOC_ENUM("DAI Bit Clock Config", max98090_bsel_enum),
1173
1174         SOC_SINGLE("DAI TDM Mode", M98090_REG_23_DAI_TDM_CONTROL,
1175                 M98090_DAI_TDM_SHIFT, M98090_DAI_TDM_NUM - 1, 0),
1176         SOC_SINGLE("DAI TDM Left Slot", M98090_REG_24_DAI_TDM_FORMAT,
1177                 M98090_DAI_TDM_SLOTL_SHIFT, M98090_DAI_TDM_SLOTL_NUM - 1, 0),
1178         SOC_SINGLE("DAI TDM Right Slot", M98090_REG_24_DAI_TDM_FORMAT,
1179                 M98090_DAI_TDM_SLOTR_SHIFT, M98090_DAI_TDM_SLOTR_NUM - 1, 0),
1180         SOC_SINGLE("DAI TDM Delay", M98090_REG_24_DAI_TDM_FORMAT,
1181                 M98090_DAI_TDM_SLOTDLY_SHIFT,
1182                 M98090_DAI_TDM_SLOTDLY_NUM - 1, 0),
1183
1184         SOC_ENUM("DMIC MIC Clock Config", max98090_micclk_enum),
1185         SOC_SINGLE("DMIC MIC Comp Filter Config", M98090_REG_14_MIC_CFG2,
1186                 M98090_DMIC_COMP_SHIFT, M98090_DMIC_COMP_NUM - 1, 0),
1187         SOC_ENUM("DMIC MIC Freq Range Config", max98090_dmicfreq_enum),
1188
1189         SOC_ENUM_EXT("External MIC Mux", max98090_extmic_mux_enum,
1190                 max98090_extmic_mux_get, max98090_extmic_mux_set),
1191
1192         SOC_SINGLE_EXT_TLV("MIC1 Boost Volume",
1193                 M98090_REG_10_LVL_MIC1, M98090_MIC_PA1EN_SHIFT,
1194                 M98090_MIC_PA1EN_NUM - 1, 0, max98090_mic1pre_volume_get,
1195                 max98090_mic1pre_volume_set, max98090_micboost_tlv),
1196
1197         SOC_SINGLE_EXT_TLV("MIC2 Boost Volume",
1198                 M98090_REG_11_LVL_MIC2, M98090_MIC_PA2EN_SHIFT,
1199                 M98090_MIC_PA2EN_NUM - 1, 0, max98090_mic2pre_volume_get,
1200                 max98090_mic2pre_volume_set, max98090_micboost_tlv),
1201
1202         SOC_SINGLE_TLV("MIC1 Volume", M98090_REG_10_LVL_MIC1,
1203                 M98090_MIC_PGAM1_SHIFT, M98090_MIC_PGAM1_NUM - 1, 1,
1204                 max98090_mic_tlv),
1205
1206         SOC_SINGLE_TLV("MIC2 Volume", M98090_REG_11_LVL_MIC2,
1207                 M98090_MIC_PGAM2_SHIFT, M98090_MIC_PGAM2_NUM - 1, 1,
1208                 max98090_mic_tlv),
1209
1210         SOC_ENUM("LINEA Single Ended Reduction", max98090_mixg135_enum),
1211         SOC_ENUM("LINEB Single Ended Reduction", max98090_mixg246_enum),
1212
1213         SOC_SINGLE_EXT_TLV("LINEA Volume", M98090_REG_0E_LVL_LINE,
1214                 M98090_LINAPGA_SHIFT, M98090_LINAPGA_NUM - 1, 1,
1215                 max98090_linea_get, max98090_linea_set, max98090_lin_tlv),
1216
1217         SOC_SINGLE_EXT_TLV("LINEB Volume", M98090_REG_0E_LVL_LINE,
1218                 M98090_LINBPGA_SHIFT, M98090_LINBPGA_NUM - 1, 1,
1219                 max98090_lineb_get, max98090_lineb_set, max98090_lin_tlv),
1220
1221         SOC_SINGLE("LINEA Ext Resistor Gain Mode", M98090_REG_0F_CFG_LINE,
1222                 M98090_EXTBUFA_SHIFT, M98090_EXTBUFA_NUM - 1, 0),
1223         SOC_SINGLE("LINEB Ext Resistor Gain Mode", M98090_REG_0F_CFG_LINE,
1224                 M98090_EXTBUFB_SHIFT, M98090_EXTBUFB_NUM - 1, 0),
1225
1226         SOC_SINGLE_TLV("ADCL Boost Volume", M98090_REG_17_LVL_ADC_L,
1227                 M98090_ADC_AVLG_SHIFT, M98090_ADC_AVLG_NUM - 1, 0,
1228                 max98090_adcboost_tlv),
1229         SOC_SINGLE_TLV("ADCR Boost Volume", M98090_REG_18_LVL_ADC_R,
1230                 M98090_ADC_AVRG_SHIFT, M98090_ADC_AVLG_NUM - 1, 0,
1231                 max98090_adcboost_tlv),
1232
1233         SOC_SINGLE_TLV("ADCL Volume", M98090_REG_17_LVL_ADC_L,
1234                 M98090_ADC_AVL_SHIFT, M98090_ADC_AVL_NUM - 1, 1,
1235                 max98090_adc_tlv),
1236         SOC_SINGLE_TLV("ADCR Volume", M98090_REG_18_LVL_ADC_R,
1237                 M98090_ADC_AVR_SHIFT, M98090_ADC_AVR_NUM - 1, 1,
1238                 max98090_adc_tlv),
1239
1240         SOC_ENUM("ADC Oversampling Rate", max98090_osr128_enum),
1241         SOC_SINGLE("ADC Quantizer Dither", M98090_REG_44_ADC_CFG,
1242                 M98090_ADCDITHER_SHIFT, M98090_ADCDITHER_NUM - 1, 0),
1243         SOC_SINGLE("ADC High Performance Mode", M98090_REG_44_ADC_CFG,
1244                 M98090_ADCHP_SHIFT, M98090_ADCHP_NUM - 1, 0),
1245
1246         SOC_SINGLE("DAC Mono Mode", M98090_REG_25_DAI_IOCFG,
1247                 M98090_DAI_DMONO_SHIFT, M98090_DAI_DMONO_NUM - 1, 0),
1248         SOC_ENUM("SDIN Mode", max98090_sdien_enum),
1249         SOC_ENUM("SDOUT Mode", max98090_sdoen_enum),
1250         SOC_ENUM("SDOUT Hi-Z Mode", max98090_hizoff_enum),
1251         SOC_ENUM("Filter Mode", max98090_filter_mode_enum),
1252         SOC_SINGLE("Record Path DC Blocking", M98090_REG_26_DAI_FILTERS,
1253                 M98090_DAI_FLT_AHPF_SHIFT, M98090_DAI_FLT_AHPF_NUM - 1, 0),
1254         SOC_SINGLE("Playback Path DC Blocking", M98090_REG_26_DAI_FILTERS,
1255                 M98090_DAI_FLT_DHPF_SHIFT, M98090_DAI_FLT_DHPF_NUM - 1, 0),
1256         SOC_SINGLE_TLV("Digital BQ Level Volume",
1257                 M98090_REG_19_LVL_BIQUAD, M98090_AVBQ_SHIFT,
1258                 M98090_AVBQ_NUM - 1, 1, max98090_dv_tlv),
1259         SOC_ENUM("Digital Sidetone Source", max98090_dsts_enum),
1260         SOC_SINGLE_EXT_TLV("Digital Sidetone Level Volume",
1261                 M98090_REG_1A_LVL_SIDETONE, M98090_DVST_SHIFT,
1262                 M98090_DVST_NUM - 1, 1, max98090_sidetone_volume_get,
1263                 max98090_sidetone_volume_set, max98090_sidetone_tlv),
1264         SOC_SINGLE_TLV("Digital Gain Volume", M98090_REG_27_DAI_LVL,
1265                 M98090_DAI_LVL_DVG_SHIFT, M98090_DAI_LVL_DVG_NUM - 1, 0,
1266                 max98090_dvg_tlv),
1267         SOC_SINGLE_TLV("Digital Level Volume", M98090_REG_27_DAI_LVL,
1268                 M98090_DAI_LVL_DV_SHIFT, M98090_DAI_LVL_DV_NUM - 1, 1,
1269                 max98090_dv_tlv),
1270         SOC_SINGLE("Digital EQ 3 Band Enable", M98090_REG_41_DSP_EQ_EN,
1271                 M98090_EQ3BANDEN_SHIFT, M98090_EQ3BANDEN_NUM - 1, 0),
1272         SOC_SINGLE("Digital EQ 5 Band Enable", M98090_REG_41_DSP_EQ_EN,
1273                 M98090_EQ5BANDEN_SHIFT, M98090_EQ5BANDEN_NUM - 1, 0),
1274         SOC_SINGLE("Digital EQ 7 Band Enable", M98090_REG_41_DSP_EQ_EN,
1275                 M98090_EQ7BANDEN_SHIFT, M98090_EQ7BANDEN_NUM - 1, 0),
1276         SOC_ENUM("Digital EQ Clipping Detection", max98090_eqclpn_enum),
1277         SOC_SINGLE_TLV("Digital EQ Level Volume",
1278                 M98090_REG_28_DAI_LVL_EQ, M98090_DAI_LVL_DVEQ_SHIFT,
1279                 M98090_DAI_LVL_DVEQ_NUM - 1, 1, max98090_dv_tlv),
1280
1281         SOC_SINGLE("ALC Enable", M98090_REG_33_ALC_TIMING,
1282                 M98090_ALCEN_SHIFT, M98090_ALCEN_NUM - 1, 0),
1283         SOC_ENUM("ALC Attack Time", max98090_alcatk_enum),
1284         SOC_ENUM("ALC Release Time", max98090_alcrls_enum),
1285         SOC_SINGLE_TLV("ALC Make Up Gain Volume",
1286                 M98090_REG_36_LVL_ALC, M98090_ALCG_SHIFT,
1287                 M98090_ALCG_NUM - 1, 0, max98090_alcmakeup_tlv),
1288         SOC_ENUM("ALC Compression Ratio", max98090_alccmp_enum),
1289         SOC_ENUM("ALC Expansion Ratio", max98090_alcexp_enum),
1290         SOC_SINGLE_TLV("ALC Compression Threshold Volume",
1291                 M98090_REG_34_ALC_CMPR, M98090_ALCTHC_SHIFT,
1292                 M98090_ALCTHC_NUM - 1, 1, max98090_alccomp_tlv),
1293         SOC_SINGLE_TLV("ALC Expansion Threshold Volume",
1294                 M98090_REG_35_ALC_EXP, M98090_ALCTHE_SHIFT,
1295                 M98090_ALCTHE_NUM - 1, 1, max98090_alcexp_tlv),
1296
1297         SOC_SINGLE("DAC HP Playback Performance Mode", M98090_REG_43_DAC_CFG,
1298                 M98090_DAC_PERFMODE_SHIFT, M98090_DAC_PERFMODE_NUM - 1, 0),
1299         SOC_SINGLE("DAC High Performance Mode", M98090_REG_43_DAC_CFG,
1300                 M98090_DACHP_SHIFT, M98090_DACHP_NUM - 1, 0),
1301
1302         SOC_SINGLE_TLV("Headphone Left Mixer Gain Volume",
1303                 M98090_REG_2B_MIX_HP_CNTL, M98090_MIXHPLG_SHIFT,
1304                 M98090_MIXHPLG_NUM - 1, 1, max98090_mixout_tlv),
1305         SOC_SINGLE_TLV("Headphone Right Mixer Gain Volume",
1306                 M98090_REG_2B_MIX_HP_CNTL, M98090_MIXHPRG_SHIFT,
1307                 M98090_MIXHPRG_NUM - 1, 1, max98090_mixout_tlv),
1308
1309         SOC_SINGLE_TLV("Speaker Left Mixer Gain Volume",
1310                 M98090_REG_30_MIX_SPK_CNTL, M98090_MIXSPLG_SHIFT,
1311                 M98090_MIXSPLG_NUM - 1, 1, max98090_mixout_tlv),
1312         SOC_SINGLE_TLV("Speaker Right Mixer Gain Volume",
1313                 M98090_REG_30_MIX_SPK_CNTL, M98090_MIXSPRG_SHIFT,
1314                 M98090_MIXSPRG_NUM - 1, 1, max98090_mixout_tlv),
1315
1316         SOC_SINGLE_TLV("Receiver Left Mixer Gain Volume",
1317                 M98090_REG_38_MIX_RCV_CTRL_LEFT, M98090_MIXRCVLG_SHIFT,
1318                 M98090_MIXRCVLG_NUM - 1, 1, max98090_mixout_tlv),
1319         SOC_SINGLE_TLV("Receiver Right Mixer Gain Volume",
1320                 M98090_REG_3B_MIX_RCV_CNTL_RIGHT, M98090_MIXRCVRG_SHIFT,
1321                 M98090_MIXRCVRG_NUM - 1, 1, max98090_mixout_tlv),
1322
1323         SOC_SINGLE_TLV("Headphone Left Volume", M98090_REG_2C_LVL_HP_LEFT,
1324                 M98090_HPVOLL_SHIFT, M98090_HPVOLL_NUM - 1, 0,
1325                 max98090_hp_tlv),
1326         SOC_SINGLE_TLV("Headphone Right Volume", M98090_REG_2D_LVL_HP_RIGHT,
1327                 M98090_HPVOLR_SHIFT, M98090_HPVOLR_NUM - 1, 0,
1328                 max98090_hp_tlv),
1329
1330         SOC_SINGLE_EXT_TLV("Speaker Left Volume",
1331                 M98090_REG_31_LVL_SPK_LEFT, M98090_SPVOLL_SHIFT,
1332                 M98090_SPVOLL_NUM - 1, 1, max98090_spkl_get,
1333                 max98090_spkl_set, max98090_spk_tlv),
1334         SOC_SINGLE_EXT_TLV("Speaker Right Volume",
1335                 M98090_REG_32_LVL_SPK_RIGHT, M98090_SPVOLR_SHIFT,
1336                 M98090_SPVOLR_NUM - 1, 1, max98090_spkr_get,
1337                 max98090_spkr_set, max98090_spk_tlv),
1338
1339         SOC_SINGLE_TLV("Receiver Left Volume", M98090_REG_39_LVL_RCV_LEFT,
1340                 M98090_RCVLVOL_SHIFT, M98090_RCVLVOL_NUM - 1, 0,
1341                 max98090_rcv_lout_tlv),
1342         SOC_SINGLE_TLV("Receiver Right Volume", M98090_REG_3C_LVL_RCV_RIGHT,
1343                 M98090_RCVRVOL_SHIFT, M98090_RCVRVOL_NUM - 1, 0,
1344                 max98090_rcv_lout_tlv),
1345
1346         SOC_SINGLE("Headphone Left Switch", M98090_REG_2C_LVL_HP_LEFT,
1347                 M98090_HPLM_SHIFT, 1, 1),
1348         SOC_SINGLE("Headphone Right Switch", M98090_REG_2D_LVL_HP_RIGHT,
1349                 M98090_HPRM_SHIFT, 1, 1),
1350
1351         SOC_SINGLE("Speaker Left Switch", M98090_REG_31_LVL_SPK_LEFT,
1352                 M98090_SPLM_SHIFT, 1, 1),
1353         SOC_SINGLE("Speaker Right Switch", M98090_REG_32_LVL_SPK_RIGHT,
1354                 M98090_SPRM_SHIFT, 1, 1),
1355
1356         SOC_SINGLE("Receiver Left Switch", M98090_REG_39_LVL_RCV_LEFT,
1357                 M98090_RCVLM_SHIFT, 1, 1),
1358         SOC_SINGLE("Receiver Right Switch", M98090_REG_3C_LVL_RCV_RIGHT,
1359                 M98090_RCVRM_SHIFT, 1, 1),
1360
1361         SOC_ENUM("Zero-Crossing Detection", max98090_zdenn_enum),
1362         SOC_ENUM("Enhanced Volume Smoothing", max98090_vs2enn_enum),
1363         SOC_ENUM("Volume Adjustment Smoothing", max98090_vsenn_enum),
1364
1365         SOC_SINGLE("Quick Setup System Clock", M98090_REG_04_QCFG_SYS_CLK,
1366                 M98090_CLK_ALL_SHIFT, M98090_CLK_ALL_NUM - 1, 0),
1367         SOC_SINGLE("Quick Setup Sample Rate", M98090_REG_05_QCFG_RATE,
1368                 M98090_SR_ALL_SHIFT, M98090_SR_ALL_NUM - 1, 0),
1369         SOC_SINGLE("Quick Setup DAI Interface", M98090_REG_06_QCFG_DAI,
1370                 M98090_DAI_ALL_SHIFT, M98090_DAI_ALL_NUM - 1, 0),
1371         SOC_SINGLE("Quick Setup DAC Path", M98090_REG_07_QCFG_DAC,
1372                 M98090_DIG2_ALL_SHIFT, M98090_DIG2_ALL_NUM - 1, 0),
1373         SOC_SINGLE("Quick Setup MIC/Direct ADC", M98090_REG_08_QCFG_MIC_PATH,
1374                 M98090_MIC_ALL_SHIFT, M98090_MIC_ALL_NUM - 1, 0),
1375         SOC_SINGLE("Quick Setup Line ADC", M98090_REG_09_QCFG_LINE_PATH,
1376                 M98090_LINE_ALL_SHIFT, M98090_LINE_ALL_NUM - 1, 0),
1377         SOC_SINGLE("Quick Setup Analog MIC Loop",
1378                 M98090_REG_0A_QCFG_MIC_LOOP, M98090_AMIC_ALL_SHIFT,
1379                 M98090_AMIC_ALL_NUM - 1, 0),
1380         SOC_SINGLE("Quick Setup Analog Line Loop",
1381                 M98090_REG_0B_QCFG_LINE_LOOP, M98090_ALIN_ALL_SHIFT,
1382                 M98090_ALIN_ALL_NUM - 1, 0),
1383
1384         SOC_SINGLE("Biquad Switch", M98090_REG_41_DSP_EQ_EN,
1385                 M98090_ADCBQEN_SHIFT, M98090_ADCBQEN_NUM - 1, 0),
1386 };
1387
1388 static const struct snd_kcontrol_new max98091_snd_controls[] = {
1389         SOC_SINGLE("DAI TDM ADCL Slot", M98090_REG_C1_RECORD_TDM_SLOT,
1390                 M98090_DAI_TDM_SLOTADCL_SHIFT,
1391                 M98090_DAI_TDM_SLOTADCL_NUM - 1, 0),
1392         SOC_SINGLE("DAI TDM ADCR Slot", M98090_REG_C1_RECORD_TDM_SLOT,
1393                 M98090_DAI_TDM_SLOTADCR_SHIFT,
1394                 M98090_DAI_TDM_SLOTADCR_NUM - 1, 0),
1395         SOC_SINGLE("DAI TDM MIC3 Slot", M98090_REG_C1_RECORD_TDM_SLOT,
1396                 M98090_DAI_TDM_SLOTDMIC3_SHIFT,
1397                 M98090_DAI_TDM_SLOTDMIC3_NUM - 1, 0),
1398         SOC_SINGLE("DAI TDM MIC4 Slot", M98090_REG_C1_RECORD_TDM_SLOT,
1399                 M98090_DAI_TDM_SLOTDMIC4_SHIFT,
1400                 M98090_DAI_TDM_SLOTDMIC4_NUM - 1, 0),
1401
1402         SOC_ENUM("DMIC34 MIC Clock Config", max98090_dmic34clk_enum),
1403         SOC_SINGLE("DMIC34 Zeropad", M98090_REG_C2_SAMPLE_RATE,
1404                 M98090_DMIC34_ZEROPAD_SHIFT,
1405                 M98090_DMIC34_ZEROPAD_NUM - 1, 0),
1406
1407         SOC_ENUM("Filter DMIC34 Mode", max98090_filter_dmic34mode_enum),
1408         SOC_SINGLE("DMIC34 DC Blocking", M98090_REG_26_DAI_FILTERS,
1409                 M98090_DAI_FLT_DMIC34HPF_SHIFT,
1410                 M98090_DAI_FLT_DMIC34HPF_NUM - 1, 0),
1411
1412         SOC_SINGLE_TLV("DMIC3 Boost Volume", M98090_REG_BE_DMIC3_VOLUME,
1413                 M98090_DMIC_AV3G_SHIFT, M98090_DMIC_AV3G_NUM - 1, 0,
1414                 max98090_adcboost_tlv),
1415         SOC_SINGLE_TLV("DMIC4 Boost Volume", M98090_REG_BF_DMIC4_VOLUME,
1416                 M98090_DMIC_AV4G_SHIFT, M98090_DMIC_AV4G_NUM - 1, 0,
1417                 max98090_adcboost_tlv),
1418
1419         SOC_SINGLE_TLV("DMIC3 Volume", M98090_REG_BE_DMIC3_VOLUME,
1420                 M98090_DMIC_AV3_SHIFT, M98090_DMIC_AV3_NUM - 1, 1,
1421                 max98090_adc_tlv),
1422         SOC_SINGLE_TLV("DMIC4 Volume", M98090_REG_BF_DMIC4_VOLUME,
1423                 M98090_DMIC_AV4_SHIFT, M98090_DMIC_AV4_NUM - 1, 1,
1424                 max98090_adc_tlv),
1425
1426         SOC_SINGLE("DMIC34 Biquad Switch", M98090_REG_41_DSP_EQ_EN,
1427                 M98090_DMIC34BQEN_SHIFT, M98090_DMIC34BQEN_NUM - 1, 0),
1428
1429         SOC_SINGLE_TLV("DMIC34 BQ PreAttenuation Level Volume",
1430                 M98090_REG_C0_DMIC34_BQ_PREATTEN, M98090_AV34BQ_SHIFT,
1431                 M98090_AV34BQ_NUM - 1, 1, max98090_dv_tlv),
1432
1433         SOC_SINGLE("Rev ID", M98090_REG_FF_REV_ID,
1434                 M98090_REVID_SHIFT, M98090_REVID_NUM - 1, 0),
1435 };
1436
1437 static int max98090_mic1_mux_event(struct snd_soc_dapm_widget *w,
1438                                  struct snd_kcontrol *kcontrol, int event)
1439 {
1440         struct snd_soc_codec *codec = w->codec;
1441         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
1442
1443         unsigned int val = snd_soc_read(codec, M98090_REG_0F_CFG_LINE);
1444
1445         val = (val & M98090_EXTMIC_MASK) >> M98090_EXTMIC_SHIFT;
1446
1447         if ((val == (M98090_EXTMIC_MIC1 >> M98090_EXTMIC_SHIFT)) ||
1448                 (val == (M98090_EXTMIC_MIC2 >> M98090_EXTMIC_SHIFT))) {
1449                 max98090->extmic_mux = val - 1; /* Update for volatile */
1450         }
1451
1452         switch (event) {
1453         case SND_SOC_DAPM_POST_PMU:
1454                 /* If turning on, set to selected channel */
1455                 max98090->extmic_mux = 0;
1456                 val = max98090->extmic_mux + 1;
1457                 break;
1458         case SND_SOC_DAPM_POST_PMD:
1459                 /* If turning off, turn off */
1460                 val = M98090_EXTMIC_NONE >> M98090_EXTMIC_SHIFT;
1461                 break;
1462         default:
1463                 return -EINVAL;
1464         }
1465
1466         snd_soc_update_bits(codec, M98090_REG_0F_CFG_LINE, M98090_EXTMIC_MASK,
1467                 val << M98090_EXTMIC_SHIFT);
1468
1469         return 0;
1470 }
1471
1472 static int max98090_mic2_mux_event(struct snd_soc_dapm_widget *w,
1473                                  struct snd_kcontrol *kcontrol, int event)
1474 {
1475         struct snd_soc_codec *codec = w->codec;
1476         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
1477
1478         unsigned int val = snd_soc_read(codec, M98090_REG_0F_CFG_LINE);
1479
1480         val = (val & M98090_EXTMIC_MASK) >> M98090_EXTMIC_SHIFT;
1481
1482         if ((val == (M98090_EXTMIC_MIC1 >> M98090_EXTMIC_SHIFT)) ||
1483                 (val == (M98090_EXTMIC_MIC2 >> M98090_EXTMIC_SHIFT))) {
1484                 max98090->extmic_mux = val - 1; /* Update for volatile */
1485         }
1486
1487         switch (event) {
1488         case SND_SOC_DAPM_POST_PMU:
1489                 /* If turning on, set to selected channel */
1490                 max98090->extmic_mux = 1;
1491                 val = max98090->extmic_mux + 1;
1492                 break;
1493         case SND_SOC_DAPM_POST_PMD:
1494                 /* If turning off, turn off */
1495                 val = M98090_EXTMIC_NONE >> M98090_EXTMIC_SHIFT;
1496                 break;
1497         default:
1498                 return -EINVAL;
1499         }
1500
1501         snd_soc_update_bits(codec, M98090_REG_0F_CFG_LINE, M98090_EXTMIC_MASK,
1502                 val << M98090_EXTMIC_SHIFT);
1503
1504         return 0;
1505 }
1506
1507 static int max98090_micinput_event(struct snd_soc_dapm_widget *w,
1508                                  struct snd_kcontrol *kcontrol, int event)
1509 {
1510         struct snd_soc_codec *codec = w->codec;
1511         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
1512
1513         unsigned int val = snd_soc_read(codec, w->reg);
1514
1515         if (w->reg == M98090_REG_10_LVL_MIC1)
1516                 val = (val & M98090_MIC_PA1EN_MASK) >> M98090_MIC_PA1EN_SHIFT;
1517         else
1518                 val = (val & M98090_MIC_PA2EN_MASK) >> M98090_MIC_PA2EN_SHIFT;
1519
1520
1521         if (val >= 1) {
1522                 if (w->reg == M98090_REG_10_LVL_MIC1)
1523                         max98090->mic1pre = val - 1; /* Update for volatile */
1524                 else
1525                         max98090->mic2pre = val - 1; /* Update for volatile */
1526         }
1527
1528         switch (event) {
1529         case SND_SOC_DAPM_POST_PMU:
1530                 /* If turning on, set to most recently selected volume */
1531                 if (w->reg == M98090_REG_10_LVL_MIC1)
1532                         val = max98090->mic1pre + 1;
1533                 else
1534                         val = max98090->mic2pre + 1;
1535                 break;
1536         case SND_SOC_DAPM_POST_PMD:
1537                 /* If turning off, turn off */
1538                 val = 0;
1539                 break;
1540         default:
1541                 return -EINVAL;
1542         }
1543
1544         if (w->reg == M98090_REG_10_LVL_MIC1)
1545                 snd_soc_update_bits(codec, w->reg, M98090_MIC_PA1EN_MASK,
1546                         val << M98090_MIC_PA1EN_SHIFT);
1547         else
1548                 snd_soc_update_bits(codec, w->reg, M98090_MIC_PA2EN_MASK,
1549                         val << M98090_MIC_PA2EN_SHIFT);
1550
1551         return 0;
1552 }
1553
1554 static int max98090_sidetone_event(struct snd_soc_dapm_widget *w,
1555                                  struct snd_kcontrol *kcontrol, int event)
1556 {
1557         struct snd_soc_codec *codec = w->codec;
1558         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
1559
1560         switch (event) {
1561         case SND_SOC_DAPM_POST_PMU:
1562                 snd_soc_update_bits(codec, w->reg, M98090_DVST_MASK,
1563                         (1 + max98090->sidetone) << M98090_DVST_SHIFT);
1564                 break;
1565         case SND_SOC_DAPM_POST_PMD:
1566                 snd_soc_update_bits(codec, w->reg, M98090_DVST_MASK, 0);
1567                 break;
1568         default:
1569                 return -EINVAL;
1570         }
1571
1572         return 0;
1573 }
1574
1575 static const char * const mic1_mux_text[] = { "IN12", "IN56" };
1576
1577 static const struct soc_enum mic1_mux_enum =
1578         SOC_ENUM_SINGLE(M98090_REG_0F_CFG_LINE, M98090_EXTMIC1_SHIFT,
1579                 ARRAY_SIZE(mic1_mux_text), mic1_mux_text);
1580
1581 static const struct snd_kcontrol_new max98090_mic1_mux =
1582         SOC_DAPM_ENUM("MIC1 Mux", mic1_mux_enum);
1583
1584 static const char * const mic2_mux_text[] = { "IN34", "IN56" };
1585
1586 static const struct soc_enum mic2_mux_enum =
1587         SOC_ENUM_SINGLE(M98090_REG_0F_CFG_LINE, M98090_EXTMIC2_SHIFT,
1588                 ARRAY_SIZE(mic2_mux_text), mic2_mux_text);
1589
1590 static const struct snd_kcontrol_new max98090_mic2_mux =
1591         SOC_DAPM_ENUM("MIC2 Mux", mic2_mux_enum);
1592
1593 static const char * const max98090_micpre_text[] = { "Off", "On" };
1594
1595 static const struct soc_enum max98090_mic1pre_enum =
1596         SOC_ENUM_SINGLE(M98090_REG_10_LVL_MIC1, M98090_MIC_PA1EN_SHIFT,
1597                 ARRAY_SIZE(max98090_micpre_text), max98090_micpre_text);
1598
1599 static const struct soc_enum max98090_mic2pre_enum =
1600         SOC_ENUM_SINGLE(M98090_REG_11_LVL_MIC2, M98090_MIC_PA2EN_SHIFT,
1601                 ARRAY_SIZE(max98090_micpre_text), max98090_micpre_text);
1602
1603 static const char * const max98090_extmic_text[] = { "Off", "On" };
1604
1605 static const struct soc_enum max98090_extmic_enum =
1606         SOC_ENUM_SINGLE(M98090_REG_0F_CFG_LINE, M98090_EXTMIC_SHIFT,
1607                 ARRAY_SIZE(max98090_extmic_text), max98090_extmic_text);
1608
1609 static const struct snd_kcontrol_new max98090_extmic =
1610         SOC_DAPM_ENUM("External MIC", max98090_extmic_enum);
1611
1612 /* LINEA mixer switch */
1613 static const struct snd_kcontrol_new max98090_linea_mixer_controls[] = {
1614         SOC_DAPM_SINGLE("IN1 Switch", M98090_REG_0D_CFG_INPUT,
1615                 M98090_IN1SEEN_SHIFT, 1, 0),
1616         SOC_DAPM_SINGLE("IN3 Switch", M98090_REG_0D_CFG_INPUT,
1617                 M98090_IN3SEEN_SHIFT, 1, 0),
1618         SOC_DAPM_SINGLE("IN5 Switch", M98090_REG_0D_CFG_INPUT,
1619                 M98090_IN5SEEN_SHIFT, 1, 0),
1620         SOC_DAPM_SINGLE("IN34 Switch", M98090_REG_0D_CFG_INPUT,
1621                 M98090_IN34DIFF_SHIFT, 1, 0),
1622 };
1623
1624 /* LINEB mixer switch */
1625 static const struct snd_kcontrol_new max98090_lineb_mixer_controls[] = {
1626         SOC_DAPM_SINGLE("IN2 Switch", M98090_REG_0D_CFG_INPUT,
1627                 M98090_IN2SEEN_SHIFT, 1, 0),
1628         SOC_DAPM_SINGLE("IN4 Switch", M98090_REG_0D_CFG_INPUT,
1629                 M98090_IN4SEEN_SHIFT, 1, 0),
1630         SOC_DAPM_SINGLE("IN6 Switch", M98090_REG_0D_CFG_INPUT,
1631                 M98090_IN6SEEN_SHIFT, 1, 0),
1632         SOC_DAPM_SINGLE("IN56 Switch", M98090_REG_0D_CFG_INPUT,
1633                 M98090_IN56DIFF_SHIFT, 1, 0),
1634 };
1635
1636 /* Left ADC mixer switch */
1637 static const struct snd_kcontrol_new max98090_left_adc_mixer_controls[] = {
1638         SOC_DAPM_SINGLE("IN12 Switch", M98090_REG_15_MIX_ADC_L,
1639                 M98090_MIXADL_IN12DIFF_SHIFT, 1, 0),
1640         SOC_DAPM_SINGLE("IN34 Switch", M98090_REG_15_MIX_ADC_L,
1641                 M98090_MIXADL_IN34DIFF_SHIFT, 1, 0),
1642         SOC_DAPM_SINGLE("IN56 Switch", M98090_REG_15_MIX_ADC_L,
1643                 M98090_MIXADL_IN65DIFF_SHIFT, 1, 0),
1644         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_15_MIX_ADC_L,
1645                 M98090_MIXADL_LINEA_SHIFT, 1, 0),
1646         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_15_MIX_ADC_L,
1647                 M98090_MIXADL_LINEB_SHIFT, 1, 0),
1648         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_15_MIX_ADC_L,
1649                 M98090_MIXADL_MIC1_SHIFT, 1, 0),
1650         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_15_MIX_ADC_L,
1651                 M98090_MIXADL_MIC2_SHIFT, 1, 0),
1652 };
1653
1654 /* Right ADC mixer switch */
1655 static const struct snd_kcontrol_new max98090_right_adc_mixer_controls[] = {
1656         SOC_DAPM_SINGLE("IN12 Switch", M98090_REG_16_MIX_ADC_R,
1657                 M98090_MIXADR_IN12DIFF_SHIFT, 1, 0),
1658         SOC_DAPM_SINGLE("IN34 Switch", M98090_REG_16_MIX_ADC_R,
1659                 M98090_MIXADR_IN34DIFF_SHIFT, 1, 0),
1660         SOC_DAPM_SINGLE("IN56 Switch", M98090_REG_16_MIX_ADC_R,
1661                 M98090_MIXADR_IN65DIFF_SHIFT, 1, 0),
1662         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_16_MIX_ADC_R,
1663                 M98090_MIXADR_LINEA_SHIFT, 1, 0),
1664         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_16_MIX_ADC_R,
1665                 M98090_MIXADR_LINEB_SHIFT, 1, 0),
1666         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_16_MIX_ADC_R,
1667                 M98090_MIXADR_MIC1_SHIFT, 1, 0),
1668         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_16_MIX_ADC_R,
1669                 M98090_MIXADR_MIC2_SHIFT, 1, 0),
1670 };
1671
1672 static const char * const lten_mux_text[] = { "Normal", "Loopthrough" };
1673
1674 static const struct soc_enum ltenl_mux_enum =
1675         SOC_ENUM_SINGLE(M98090_REG_25_DAI_IOCFG, M98090_DAI_LTEN_SHIFT,
1676                 ARRAY_SIZE(lten_mux_text), lten_mux_text);
1677
1678 static const struct soc_enum ltenr_mux_enum =
1679         SOC_ENUM_SINGLE(M98090_REG_25_DAI_IOCFG, M98090_DAI_LTEN_SHIFT,
1680                 ARRAY_SIZE(lten_mux_text), lten_mux_text);
1681
1682 static const struct snd_kcontrol_new max98090_ltenl_mux =
1683         SOC_DAPM_ENUM("LTENL Mux", ltenl_mux_enum);
1684
1685 static const struct snd_kcontrol_new max98090_ltenr_mux =
1686         SOC_DAPM_ENUM("LTENR Mux", ltenr_mux_enum);
1687
1688 static const char * const lben_mux_text[] = { "Normal", "Loopback" };
1689
1690 static const struct soc_enum lbenl_mux_enum =
1691         SOC_ENUM_SINGLE(M98090_REG_25_DAI_IOCFG, M98090_DAI_LBEN_SHIFT,
1692                 ARRAY_SIZE(lben_mux_text), lben_mux_text);
1693
1694 static const struct soc_enum lbenr_mux_enum =
1695         SOC_ENUM_SINGLE(M98090_REG_25_DAI_IOCFG, M98090_DAI_LBEN_SHIFT,
1696                 ARRAY_SIZE(lben_mux_text), lben_mux_text);
1697
1698 static const struct snd_kcontrol_new max98090_lbenl_mux =
1699         SOC_DAPM_ENUM("LBENL Mux", lbenl_mux_enum);
1700
1701 static const struct snd_kcontrol_new max98090_lbenr_mux =
1702         SOC_DAPM_ENUM("LBENR Mux", lbenr_mux_enum);
1703
1704 /* Left speaker mixer switch */
1705 static const struct
1706         snd_kcontrol_new max98090_left_speaker_mixer_controls[] = {
1707         SOC_DAPM_SINGLE("Left DAC Switch", M98090_REG_2E_MIX_SPK_LEFT,
1708                 M98090_MIXSPL_DACL_SHIFT, 1, 0),
1709         SOC_DAPM_SINGLE("Right DAC Switch", M98090_REG_2E_MIX_SPK_LEFT,
1710                 M98090_MIXSPL_DACR_SHIFT, 1, 0),
1711         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_2E_MIX_SPK_LEFT,
1712                 M98090_MIXSPL_LINEA_SHIFT, 1, 0),
1713         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_2E_MIX_SPK_LEFT,
1714                 M98090_MIXSPL_LINEB_SHIFT, 1, 0),
1715         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_2E_MIX_SPK_LEFT,
1716                 M98090_MIXSPL_MIC1_SHIFT, 1, 0),
1717         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_2E_MIX_SPK_LEFT,
1718                 M98090_MIXSPL_MIC2_SHIFT, 1, 0),
1719 };
1720
1721 /* Right speaker mixer switch */
1722 static const struct
1723         snd_kcontrol_new max98090_right_speaker_mixer_controls[] = {
1724         SOC_DAPM_SINGLE("Left DAC Switch", M98090_REG_2F_MIX_SPK_RIGHT,
1725                 M98090_MIXSPR_DACL_SHIFT, 1, 0),
1726         SOC_DAPM_SINGLE("Right DAC Switch", M98090_REG_2F_MIX_SPK_RIGHT,
1727                 M98090_MIXSPR_DACR_SHIFT, 1, 0),
1728         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_2F_MIX_SPK_RIGHT,
1729                 M98090_MIXSPR_LINEA_SHIFT, 1, 0),
1730         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_2F_MIX_SPK_RIGHT,
1731                 M98090_MIXSPR_LINEB_SHIFT, 1, 0),
1732         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_2F_MIX_SPK_RIGHT,
1733                 M98090_MIXSPR_MIC1_SHIFT, 1, 0),
1734         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_2F_MIX_SPK_RIGHT,
1735                 M98090_MIXSPR_MIC2_SHIFT, 1, 0),
1736 };
1737
1738 /* Left headphone mixer switch */
1739 static const struct snd_kcontrol_new max98090_left_hp_mixer_controls[] = {
1740         SOC_DAPM_SINGLE("Left DAC Switch", M98090_REG_29_MIX_HP_LEFT,
1741                 M98090_MIXHPL_DACL_SHIFT, 1, 0),
1742         SOC_DAPM_SINGLE("Right DAC Switch", M98090_REG_29_MIX_HP_LEFT,
1743                 M98090_MIXHPL_DACR_SHIFT, 1, 0),
1744         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_29_MIX_HP_LEFT,
1745                 M98090_MIXHPL_LINEA_SHIFT, 1, 0),
1746         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_29_MIX_HP_LEFT,
1747                 M98090_MIXHPL_LINEB_SHIFT, 1, 0),
1748         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_29_MIX_HP_LEFT,
1749                 M98090_MIXHPL_MIC1_SHIFT, 1, 0),
1750         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_29_MIX_HP_LEFT,
1751                 M98090_MIXHPL_MIC2_SHIFT, 1, 0),
1752 };
1753
1754 /* Right headphone mixer switch */
1755 static const struct snd_kcontrol_new max98090_right_hp_mixer_controls[] = {
1756         SOC_DAPM_SINGLE("Left DAC Switch", M98090_REG_2A_MIX_HP_RIGHT,
1757                 M98090_MIXHPR_DACL_SHIFT, 1, 0),
1758         SOC_DAPM_SINGLE("Right DAC Switch", M98090_REG_2A_MIX_HP_RIGHT,
1759                 M98090_MIXHPR_DACR_SHIFT, 1, 0),
1760         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_2A_MIX_HP_RIGHT,
1761                 M98090_MIXHPR_LINEA_SHIFT, 1, 0),
1762         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_2A_MIX_HP_RIGHT,
1763                 M98090_MIXHPR_LINEB_SHIFT, 1, 0),
1764         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_2A_MIX_HP_RIGHT,
1765                 M98090_MIXHPR_MIC1_SHIFT, 1, 0),
1766         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_2A_MIX_HP_RIGHT,
1767                 M98090_MIXHPR_MIC2_SHIFT, 1, 0),
1768 };
1769
1770 /* Left receiver mixer switch */
1771 static const struct snd_kcontrol_new max98090_left_rcv_mixer_controls[] = {
1772         SOC_DAPM_SINGLE("Left DAC Switch", M98090_REG_37_MIX_RCV_LEFT,
1773                 M98090_MIXRCVL_DACL_SHIFT, 1, 0),
1774         SOC_DAPM_SINGLE("Right DAC Switch", M98090_REG_37_MIX_RCV_LEFT,
1775                 M98090_MIXRCVL_DACR_SHIFT, 1, 0),
1776         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_37_MIX_RCV_LEFT,
1777                 M98090_MIXRCVL_LINEA_SHIFT, 1, 0),
1778         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_37_MIX_RCV_LEFT,
1779                 M98090_MIXRCVL_LINEB_SHIFT, 1, 0),
1780         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_37_MIX_RCV_LEFT,
1781                 M98090_MIXRCVL_MIC1_SHIFT, 1, 0),
1782         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_37_MIX_RCV_LEFT,
1783                 M98090_MIXRCVL_MIC2_SHIFT, 1, 0),
1784 };
1785
1786 /* Right receiver mixer switch */
1787 static const struct snd_kcontrol_new max98090_right_rcv_mixer_controls[] = {
1788         SOC_DAPM_SINGLE("Left DAC Switch", M98090_REG_3A_MIX_RCV_RIGHT,
1789                 M98090_MIXRCVR_DACL_SHIFT, 1, 0),
1790         SOC_DAPM_SINGLE("Right DAC Switch", M98090_REG_3A_MIX_RCV_RIGHT,
1791                 M98090_MIXRCVR_DACR_SHIFT, 1, 0),
1792         SOC_DAPM_SINGLE("LINEA Switch", M98090_REG_3A_MIX_RCV_RIGHT,
1793                 M98090_MIXRCVR_LINEA_SHIFT, 1, 0),
1794         SOC_DAPM_SINGLE("LINEB Switch", M98090_REG_3A_MIX_RCV_RIGHT,
1795                 M98090_MIXRCVR_LINEB_SHIFT, 1, 0),
1796         SOC_DAPM_SINGLE("MIC1 Switch", M98090_REG_3A_MIX_RCV_RIGHT,
1797                 M98090_MIXRCVR_MIC1_SHIFT, 1, 0),
1798         SOC_DAPM_SINGLE("MIC2 Switch", M98090_REG_3A_MIX_RCV_RIGHT,
1799                 M98090_MIXRCVR_MIC2_SHIFT, 1, 0),
1800 };
1801
1802 static const char * const linmod_mux_text[] = {
1803         "Left Only", "Left and Right" };
1804
1805 static const struct soc_enum linmod_mux_enum =
1806         SOC_ENUM_SINGLE(M98090_REG_3A_MIX_RCV_RIGHT, M98090_LINMOD_SHIFT,
1807                 ARRAY_SIZE(linmod_mux_text), linmod_mux_text);
1808
1809 static const struct snd_kcontrol_new max98090_linmod_mux =
1810         SOC_DAPM_ENUM("LINMOD Mux", linmod_mux_enum);
1811
1812 static const char * const mixhpsel_mux_text[] = { "DAC Only", "HP Mixer" };
1813
1814 /*
1815  * This is a mux as it selects the HP output,
1816  * but to DAPM it is a Mixer enable
1817  */
1818 static const struct soc_enum mixhplsel_mux_enum =
1819         SOC_ENUM_SINGLE(M98090_REG_2B_MIX_HP_CNTL, M98090_MIXHPLSEL_SHIFT,
1820                 ARRAY_SIZE(mixhpsel_mux_text), mixhpsel_mux_text);
1821
1822 static const struct snd_kcontrol_new max98090_mixhplsel_mux =
1823         SOC_DAPM_ENUM("MIXHPLSEL Mux", mixhplsel_mux_enum);
1824
1825 static const struct soc_enum mixhprsel_mux_enum =
1826         SOC_ENUM_SINGLE(M98090_REG_2B_MIX_HP_CNTL, M98090_MIXHPRSEL_SHIFT,
1827                 ARRAY_SIZE(mixhpsel_mux_text), mixhpsel_mux_text);
1828
1829 static const struct snd_kcontrol_new max98090_mixhprsel_mux =
1830         SOC_DAPM_ENUM("MIXHPRSEL Mux", mixhprsel_mux_enum);
1831
1832 static const struct snd_soc_dapm_widget max98090_dapm_widgets[] = {
1833
1834         SND_SOC_DAPM_INPUT("MIC1"),
1835         SND_SOC_DAPM_INPUT("MIC2"),
1836         SND_SOC_DAPM_INPUT("DMICL"),
1837         SND_SOC_DAPM_INPUT("DMICR"),
1838         SND_SOC_DAPM_INPUT("IN1"),
1839         SND_SOC_DAPM_INPUT("IN2"),
1840         SND_SOC_DAPM_INPUT("IN3"),
1841         SND_SOC_DAPM_INPUT("IN4"),
1842         SND_SOC_DAPM_INPUT("IN5"),
1843         SND_SOC_DAPM_INPUT("IN6"),
1844         SND_SOC_DAPM_INPUT("IN12"),
1845         SND_SOC_DAPM_INPUT("IN34"),
1846         SND_SOC_DAPM_INPUT("IN56"),
1847
1848         SND_SOC_DAPM_MICBIAS("MICBIAS", M98090_REG_3E_PWR_EN_IN,
1849                 M98090_PWR_MBEN_SHIFT, 0),
1850         SND_SOC_DAPM_SUPPLY("SHDN", M98090_REG_45_PWR_SYS,
1851                 M98090_PWR_SHDNN_SHIFT, 0, NULL, 0),
1852         SND_SOC_DAPM_SUPPLY("VCM", M98090_REG_42_BIAS_CNTL,
1853                 M98090_VCM_MODE_SHIFT, 0, NULL, 0),
1854         SND_SOC_DAPM_SUPPLY("SDIEN", M98090_REG_25_DAI_IOCFG,
1855                 M98090_DAI_SDIEN_SHIFT, 0, NULL, 0),
1856         SND_SOC_DAPM_SUPPLY("SDOEN", M98090_REG_25_DAI_IOCFG,
1857                 M98090_DAI_SDOEN_SHIFT, 0, NULL, 0),
1858         SND_SOC_DAPM_SUPPLY("DMICL_ENA", M98090_REG_13_MIC_CFG1,
1859                  M98090_DIGMICL_SHIFT, 0, NULL, 0),
1860         SND_SOC_DAPM_SUPPLY("DMICR_ENA", M98090_REG_13_MIC_CFG1,
1861                  M98090_DIGMICR_SHIFT, 0, NULL, 0),
1862         SND_SOC_DAPM_SUPPLY("AHPF", M98090_REG_26_DAI_FILTERS,
1863                 M98090_DAI_FLT_AHPF_SHIFT, 0, NULL, 0),
1864
1865 /*
1866  * Note: Sysclk and misc power supplies are taken care of by SHDN and VCM
1867  */
1868
1869         SND_SOC_DAPM_MUX_E("MIC1 Mux", SND_SOC_NOPM,
1870                 0, 0, &max98090_mic1_mux,
1871                 max98090_mic1_mux_event,
1872                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1873
1874         SND_SOC_DAPM_MUX_E("MIC2 Mux", SND_SOC_NOPM,
1875                 0, 0, &max98090_mic2_mux,
1876                 max98090_mic2_mux_event,
1877                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1878
1879         SND_SOC_DAPM_PGA_E("MIC1 Input", M98090_REG_10_LVL_MIC1,
1880                 M98090_MIC_PA1EN_SHIFT, 0, NULL, 0, max98090_micinput_event,
1881                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1882
1883         SND_SOC_DAPM_PGA_E("MIC2 Input", M98090_REG_11_LVL_MIC2,
1884                 M98090_MIC_PA2EN_SHIFT, 0, NULL, 0, max98090_micinput_event,
1885                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1886
1887         SND_SOC_DAPM_MIXER("LINEA Mixer", SND_SOC_NOPM, 0, 0,
1888                 &max98090_linea_mixer_controls[0],
1889                 ARRAY_SIZE(max98090_linea_mixer_controls)),
1890
1891         SND_SOC_DAPM_MIXER("LINEB Mixer", SND_SOC_NOPM, 0, 0,
1892                 &max98090_lineb_mixer_controls[0],
1893                 ARRAY_SIZE(max98090_lineb_mixer_controls)),
1894
1895         SND_SOC_DAPM_PGA("LINEA Input", M98090_REG_3E_PWR_EN_IN,
1896                 M98090_PWR_LINEAEN_SHIFT, 0, NULL, 0),
1897         SND_SOC_DAPM_PGA("LINEB Input", M98090_REG_3E_PWR_EN_IN,
1898                 M98090_PWR_LINEBEN_SHIFT, 0, NULL, 0),
1899
1900         SND_SOC_DAPM_MIXER("Left ADC Mixer", SND_SOC_NOPM, 0, 0,
1901                 &max98090_left_adc_mixer_controls[0],
1902                 ARRAY_SIZE(max98090_left_adc_mixer_controls)),
1903
1904         SND_SOC_DAPM_MIXER("Right ADC Mixer", SND_SOC_NOPM, 0, 0,
1905                 &max98090_right_adc_mixer_controls[0],
1906                 ARRAY_SIZE(max98090_right_adc_mixer_controls)),
1907
1908         SND_SOC_DAPM_ADC("ADCL", NULL, M98090_REG_3E_PWR_EN_IN,
1909                 M98090_PWR_ADLEN_SHIFT, 0),
1910         SND_SOC_DAPM_ADC("ADCR", NULL, M98090_REG_3E_PWR_EN_IN,
1911                 M98090_PWR_ADREN_SHIFT, 0),
1912
1913         SND_SOC_DAPM_AIF_OUT("AIFOUTL", "HiFi Capture", 0,
1914                 SND_SOC_NOPM, 0, 0),
1915         SND_SOC_DAPM_AIF_OUT("AIFOUTR", "HiFi Capture", 1,
1916                 SND_SOC_NOPM, 0, 0),
1917
1918         SND_SOC_DAPM_MUX("LBENL Mux", SND_SOC_NOPM,
1919                 0, 0, &max98090_lbenl_mux),
1920
1921         SND_SOC_DAPM_MUX("LBENR Mux", SND_SOC_NOPM,
1922                 0, 0, &max98090_lbenr_mux),
1923
1924         SND_SOC_DAPM_MUX("LTENL Mux", SND_SOC_NOPM,
1925                 0, 0, &max98090_ltenl_mux),
1926
1927         SND_SOC_DAPM_MUX("LTENR Mux", SND_SOC_NOPM,
1928                 0, 0, &max98090_ltenr_mux),
1929
1930         SND_SOC_DAPM_PGA_E("Sidetone", M98090_REG_1A_LVL_SIDETONE,
1931                 M98090_DVST_SHIFT, 0, NULL, 0, max98090_sidetone_event,
1932                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1933
1934         SND_SOC_DAPM_AIF_IN("AIFINL", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
1935         SND_SOC_DAPM_AIF_IN("AIFINR", "HiFi Playback", 1, SND_SOC_NOPM, 0, 0),
1936
1937         SND_SOC_DAPM_DAC("DACL", NULL, M98090_REG_3F_PWR_EN_OUT,
1938                 M98090_PWR_DALEN_SHIFT, 0),
1939         SND_SOC_DAPM_DAC("DACR", NULL, M98090_REG_3F_PWR_EN_OUT,
1940                 M98090_PWR_DAREN_SHIFT, 0),
1941
1942         SND_SOC_DAPM_MIXER("Left Headphone Mixer", SND_SOC_NOPM, 0, 0,
1943                 &max98090_left_hp_mixer_controls[0],
1944                 ARRAY_SIZE(max98090_left_hp_mixer_controls)),
1945
1946         SND_SOC_DAPM_MIXER("Right Headphone Mixer", SND_SOC_NOPM, 0, 0,
1947                 &max98090_right_hp_mixer_controls[0],
1948                 ARRAY_SIZE(max98090_right_hp_mixer_controls)),
1949
1950         SND_SOC_DAPM_MIXER("Left Speaker Mixer", SND_SOC_NOPM, 0, 0,
1951                 &max98090_left_speaker_mixer_controls[0],
1952                 ARRAY_SIZE(max98090_left_speaker_mixer_controls)),
1953
1954         SND_SOC_DAPM_MIXER("Right Speaker Mixer", SND_SOC_NOPM, 0, 0,
1955                 &max98090_right_speaker_mixer_controls[0],
1956                 ARRAY_SIZE(max98090_right_speaker_mixer_controls)),
1957
1958         SND_SOC_DAPM_MIXER("Left Receiver Mixer", SND_SOC_NOPM, 0, 0,
1959                 &max98090_left_rcv_mixer_controls[0],
1960                 ARRAY_SIZE(max98090_left_rcv_mixer_controls)),
1961
1962         SND_SOC_DAPM_MIXER("Right Receiver Mixer", SND_SOC_NOPM, 0, 0,
1963                 &max98090_right_rcv_mixer_controls[0],
1964                 ARRAY_SIZE(max98090_right_rcv_mixer_controls)),
1965
1966         SND_SOC_DAPM_MUX("LINMOD Mux", M98090_REG_3A_MIX_RCV_RIGHT,
1967                 M98090_LINMOD_SHIFT, 0, &max98090_linmod_mux),
1968
1969         SND_SOC_DAPM_MUX("MIXHPLSEL Mux", M98090_REG_2B_MIX_HP_CNTL,
1970                 M98090_MIXHPLSEL_SHIFT, 0, &max98090_mixhplsel_mux),
1971
1972         SND_SOC_DAPM_MUX("MIXHPRSEL Mux", M98090_REG_2B_MIX_HP_CNTL,
1973                 M98090_MIXHPRSEL_SHIFT, 0, &max98090_mixhprsel_mux),
1974
1975         SND_SOC_DAPM_PGA("HP Left Out", M98090_REG_3F_PWR_EN_OUT,
1976                 M98090_PWR_HPLEN_SHIFT, 0, NULL, 0),
1977         SND_SOC_DAPM_PGA("HP Right Out", M98090_REG_3F_PWR_EN_OUT,
1978                 M98090_PWR_HPREN_SHIFT, 0, NULL, 0),
1979
1980         SND_SOC_DAPM_PGA("SPK Left Out", M98090_REG_3F_PWR_EN_OUT,
1981                 M98090_PWR_SPLEN_SHIFT, 0, NULL, 0),
1982         SND_SOC_DAPM_PGA("SPK Right Out", M98090_REG_3F_PWR_EN_OUT,
1983                 M98090_PWR_SPREN_SHIFT, 0, NULL, 0),
1984
1985         SND_SOC_DAPM_PGA("RCV Left Out", M98090_REG_3F_PWR_EN_OUT,
1986                 M98090_PWR_RCVLEN_SHIFT, 0, NULL, 0),
1987         SND_SOC_DAPM_PGA("RCV Right Out", M98090_REG_3F_PWR_EN_OUT,
1988                 M98090_PWR_RCVREN_SHIFT, 0, NULL, 0),
1989
1990         SND_SOC_DAPM_OUTPUT("HPL"),
1991         SND_SOC_DAPM_OUTPUT("HPR"),
1992         SND_SOC_DAPM_OUTPUT("SPKL"),
1993         SND_SOC_DAPM_OUTPUT("SPKR"),
1994         SND_SOC_DAPM_OUTPUT("RCVL"),
1995         SND_SOC_DAPM_OUTPUT("RCVR"),
1996 };
1997
1998 static const struct snd_soc_dapm_widget max98091_dapm_widgets[] = {
1999
2000         SND_SOC_DAPM_INPUT("DMIC3"),
2001         SND_SOC_DAPM_INPUT("DMIC4"),
2002
2003         SND_SOC_DAPM_SUPPLY("DMIC3_ENA", M98090_REG_13_MIC_CFG1,
2004                  M98090_DIGMIC3_SHIFT, 0, NULL, 0),
2005         SND_SOC_DAPM_SUPPLY("DMIC4_ENA", M98090_REG_13_MIC_CFG1,
2006                  M98090_DIGMIC4_SHIFT, 0, NULL, 0),
2007         SND_SOC_DAPM_SUPPLY("DHPF", M98090_REG_26_DAI_FILTERS,
2008                 M98090_DAI_FLT_DMIC34HPF_SHIFT, 0, NULL, 0),
2009 };
2010
2011 static const struct snd_soc_dapm_route max98090_audio_map[] = {
2012
2013         {"MIC1 Input", NULL, "MIC1"},
2014         {"MIC2 Input", NULL, "MIC2"},
2015         {"MIC1 Input", NULL, "MICBIAS"},
2016         {"MIC2 Input", NULL, "MICBIAS"},
2017
2018         {"DMICL", NULL, "DMICL_ENA"},
2019         {"DMICR", NULL, "DMICR_ENA"},
2020         {"DMICL", NULL, "AHPF"},
2021         {"DMICR", NULL, "AHPF"},
2022
2023         /* MIC1 input mux */
2024         {"MIC1 Mux", "IN12", "IN12"},
2025         {"MIC1 Mux", "IN56", "IN56"},
2026
2027         /* MIC2 input mux */
2028         {"MIC2 Mux", "IN34", "IN34"},
2029         {"MIC2 Mux", "IN56", "IN56"},
2030
2031         {"MIC1 Input", NULL, "MIC1 Mux"},
2032         {"MIC2 Input", NULL, "MIC2 Mux"},
2033
2034         /* Left ADC input mixer */
2035         {"Left ADC Mixer", "IN12 Switch", "IN12"},
2036         {"Left ADC Mixer", "IN34 Switch", "IN34"},
2037         {"Left ADC Mixer", "IN56 Switch", "IN56"},
2038         {"Left ADC Mixer", "LINEA Switch", "LINEA Input"},
2039         {"Left ADC Mixer", "LINEB Switch", "LINEB Input"},
2040         {"Left ADC Mixer", "MIC1 Switch", "MIC1 Input"},
2041         {"Left ADC Mixer", "MIC2 Switch", "MIC2 Input"},
2042
2043         /* Right ADC input mixer */
2044         {"Right ADC Mixer", "IN12 Switch", "IN12"},
2045         {"Right ADC Mixer", "IN34 Switch", "IN34"},
2046         {"Right ADC Mixer", "IN56 Switch", "IN56"},
2047         {"Right ADC Mixer", "LINEA Switch", "LINEA Input"},
2048         {"Right ADC Mixer", "LINEB Switch", "LINEB Input"},
2049         {"Right ADC Mixer", "MIC1 Switch", "MIC1 Input"},
2050         {"Right ADC Mixer", "MIC2 Switch", "MIC2 Input"},
2051
2052         /* Line A input mixer */
2053         {"LINEA Mixer", "IN1 Switch", "IN1"},
2054         {"LINEA Mixer", "IN3 Switch", "IN3"},
2055         {"LINEA Mixer", "IN5 Switch", "IN5"},
2056         {"LINEA Mixer", "IN34 Switch", "IN34"},
2057
2058         /* Line B input mixer */
2059         {"LINEB Mixer", "IN2 Switch", "IN2"},
2060         {"LINEB Mixer", "IN4 Switch", "IN4"},
2061         {"LINEB Mixer", "IN6 Switch", "IN6"},
2062         {"LINEB Mixer", "IN56 Switch", "IN56"},
2063
2064         {"LINEA Input", NULL, "LINEA Mixer"},
2065         {"LINEB Input", NULL, "LINEB Mixer"},
2066
2067         /* Inputs */
2068         {"ADCL", NULL, "Left ADC Mixer"},
2069         {"ADCR", NULL, "Right ADC Mixer"},
2070         {"ADCL", NULL, "SHDN"},
2071         {"ADCR", NULL, "SHDN"},
2072         {"ADCL", NULL, "VCM"},
2073         {"ADCR", NULL, "VCM"},
2074
2075         {"LBENL Mux", "Normal", "ADCL"},
2076         {"LBENL Mux", "Normal", "DMICL"},
2077         {"LBENL Mux", "Loopback", "LTENL Mux"},
2078         {"LBENR Mux", "Normal", "ADCR"},
2079         {"LBENR Mux", "Normal", "DMICR"},
2080         {"LBENR Mux", "Loopback", "LTENR Mux"},
2081
2082         {"AIFOUTL", NULL, "LBENL Mux"},
2083         {"AIFOUTR", NULL, "LBENR Mux"},
2084         {"AIFOUTL", NULL, "SHDN"},
2085         {"AIFOUTR", NULL, "SHDN"},
2086         {"AIFOUTL", NULL, "VCM"},
2087         {"AIFOUTR", NULL, "VCM"},
2088         {"AIFOUTL", NULL, "SDOEN"},
2089         {"AIFOUTR", NULL, "SDOEN"},
2090
2091         {"LTENL Mux", "Normal", "AIFINL"},
2092         {"LTENL Mux", "Loopthrough", "LBENL Mux"},
2093         {"LTENR Mux", "Normal", "AIFINR"},
2094         {"LTENR Mux", "Loopthrough", "LBENR Mux"},
2095
2096         {"DACL", NULL, "LTENL Mux"},
2097         {"DACR", NULL, "LTENR Mux"},
2098
2099         {"STENL Mux", "Sidetone Left", "ADCL"},
2100         {"STENL Mux", "Sidetone Left", "DMICL"},
2101         {"STENR Mux", "Sidetone Right", "ADCR"},
2102         {"STENR Mux", "Sidetone Right", "DMICR"},
2103         {"DACL", NULL, "STENL Mux"},
2104         {"DACR", NULL, "STENL Mux"},
2105
2106         {"AIFINL", NULL, "SHDN"},
2107         {"AIFINR", NULL, "SHDN"},
2108         {"AIFINL", NULL, "VCM"},
2109         {"AIFINR", NULL, "VCM"},
2110         {"AIFINL", NULL, "SDIEN"},
2111         {"AIFINR", NULL, "SDIEN"},
2112         {"DACL", NULL, "SHDN"},
2113         {"DACR", NULL, "SHDN"},
2114         {"DACL", NULL, "VCM"},
2115         {"DACR", NULL, "VCM"},
2116
2117         /* Left headphone output mixer */
2118         {"Left Headphone Mixer", "Left DAC Switch", "DACL"},
2119         {"Left Headphone Mixer", "Right DAC Switch", "DACR"},
2120         {"Left Headphone Mixer", "MIC1 Switch", "MIC1 Input"},
2121         {"Left Headphone Mixer", "MIC2 Switch", "MIC2 Input"},
2122         {"Left Headphone Mixer", "LINEA Switch", "LINEA Input"},
2123         {"Left Headphone Mixer", "LINEB Switch", "LINEB Input"},
2124
2125         /* Right headphone output mixer */
2126         {"Right Headphone Mixer", "Left DAC Switch", "DACL"},
2127         {"Right Headphone Mixer", "Right DAC Switch", "DACR"},
2128         {"Right Headphone Mixer", "MIC1 Switch", "MIC1 Input"},
2129         {"Right Headphone Mixer", "MIC2 Switch", "MIC2 Input"},
2130         {"Right Headphone Mixer", "LINEA Switch", "LINEA Input"},
2131         {"Right Headphone Mixer", "LINEB Switch", "LINEB Input"},
2132
2133         /* Left speaker output mixer */
2134         {"Left Speaker Mixer", "Left DAC Switch", "DACL"},
2135         {"Left Speaker Mixer", "Right DAC Switch", "DACR"},
2136         {"Left Speaker Mixer", "MIC1 Switch", "MIC1 Input"},
2137         {"Left Speaker Mixer", "MIC2 Switch", "MIC2 Input"},
2138         {"Left Speaker Mixer", "LINEA Switch", "LINEA Input"},
2139         {"Left Speaker Mixer", "LINEB Switch", "LINEB Input"},
2140
2141         /* Right speaker output mixer */
2142         {"Right Speaker Mixer", "Left DAC Switch", "DACL"},
2143         {"Right Speaker Mixer", "Right DAC Switch", "DACR"},
2144         {"Right Speaker Mixer", "MIC1 Switch", "MIC1 Input"},
2145         {"Right Speaker Mixer", "MIC2 Switch", "MIC2 Input"},
2146         {"Right Speaker Mixer", "LINEA Switch", "LINEA Input"},
2147         {"Right Speaker Mixer", "LINEB Switch", "LINEB Input"},
2148
2149         /* Left Receiver output mixer */
2150         {"Left Receiver Mixer", "Left DAC Switch", "DACL"},
2151         {"Left Receiver Mixer", "Right DAC Switch", "DACR"},
2152         {"Left Receiver Mixer", "MIC1 Switch", "MIC1 Input"},
2153         {"Left Receiver Mixer", "MIC2 Switch", "MIC2 Input"},
2154         {"Left Receiver Mixer", "LINEA Switch", "LINEA Input"},
2155         {"Left Receiver Mixer", "LINEB Switch", "LINEB Input"},
2156
2157         /* Right Receiver output mixer */
2158         {"Right Receiver Mixer", "Left DAC Switch", "DACL"},
2159         {"Right Receiver Mixer", "Right DAC Switch", "DACR"},
2160         {"Right Receiver Mixer", "MIC1 Switch", "MIC1 Input"},
2161         {"Right Receiver Mixer", "MIC2 Switch", "MIC2 Input"},
2162         {"Right Receiver Mixer", "LINEA Switch", "LINEA Input"},
2163         {"Right Receiver Mixer", "LINEB Switch", "LINEB Input"},
2164
2165         {"MIXHPLSEL Mux", "HP Mixer", "Left Headphone Mixer"},
2166
2167         /*
2168          * Disable this for lowest power if bypassing
2169          * the DAC with an analog signal
2170          */
2171         {"HP Left Out", NULL, "DACL"},
2172         {"HP Left Out", NULL, "MIXHPLSEL Mux"},
2173
2174         {"MIXHPRSEL Mux", "HP Mixer", "Right Headphone Mixer"},
2175
2176         /*
2177          * Disable this for lowest power if bypassing
2178          * the DAC with an analog signal
2179          */
2180         {"HP Right Out", NULL, "DACR"},
2181         {"HP Right Out", NULL, "MIXHPRSEL Mux"},
2182
2183         {"SPK Left Out", NULL, "Left Speaker Mixer"},
2184         {"SPK Right Out", NULL, "Right Speaker Mixer"},
2185         {"RCV Left Out", NULL, "Left Receiver Mixer"},
2186
2187         {"LINMOD Mux", "Left and Right", "Right Receiver Mixer"},
2188         {"LINMOD Mux", "Left Only",  "Left Receiver Mixer"},
2189         {"RCV Right Out", NULL, "LINMOD Mux"},
2190
2191         {"HPL", NULL, "HP Left Out"},
2192         {"HPR", NULL, "HP Right Out"},
2193         {"SPKL", NULL, "SPK Left Out"},
2194         {"SPKR", NULL, "SPK Right Out"},
2195         {"RCVL", NULL, "RCV Left Out"},
2196         {"RCVR", NULL, "RCV Right Out"},
2197
2198 };
2199
2200 static const struct snd_soc_dapm_route max98091_dapm_routes[] = {
2201
2202         /* DMIC inputs */
2203         {"DMIC3", NULL, "DMIC3_ENA"},
2204         {"DMIC4", NULL, "DMIC4_ENA"},
2205         {"DMIC3", NULL, "DHPF"},
2206         {"DMIC4", NULL, "DHPF"},
2207
2208         {"LBENL Mux", "Normal", "DMIC3"},
2209         {"LBENR Mux", "Normal", "DMIC4"},
2210 };
2211
2212 static int max98090_add_widgets(struct snd_soc_codec *codec)
2213 {
2214         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2215         struct snd_soc_dapm_context *dapm = &codec->dapm;
2216
2217         snd_soc_add_codec_controls(codec, max98090_snd_controls,
2218                 ARRAY_SIZE(max98090_snd_controls));
2219
2220         if (max98090->devtype == MAX98091) {
2221                 snd_soc_add_codec_controls(codec, max98091_snd_controls,
2222                         ARRAY_SIZE(max98091_snd_controls));
2223         }
2224
2225         snd_soc_dapm_new_controls(dapm, max98090_dapm_widgets,
2226                 ARRAY_SIZE(max98090_dapm_widgets));
2227
2228         snd_soc_dapm_add_routes(dapm, max98090_audio_map,
2229                 ARRAY_SIZE(max98090_audio_map));
2230
2231         if (max98090->devtype == MAX98091) {
2232                 snd_soc_dapm_new_controls(dapm, max98091_dapm_widgets,
2233                         ARRAY_SIZE(max98091_dapm_widgets));
2234
2235                 snd_soc_dapm_add_routes(dapm, max98091_dapm_routes,
2236                         ARRAY_SIZE(max98091_dapm_routes));
2237         }
2238         snd_soc_dapm_new_widgets(&codec->dapm);
2239
2240         return 0;
2241 }
2242
2243 static const int pclk_rates[] = {
2244         12000000, 12000000, 13000000, 13000000,
2245         16000000, 16000000, 19200000, 19200000
2246 };
2247
2248 static const int lrclk_rates[] = {
2249         8000, 16000, 8000, 16000,
2250         8000, 16000, 8000, 16000
2251 };
2252
2253 static const int user_pclk_rates[] = {
2254         13000000, 13000000
2255 };
2256
2257 static const int user_lrclk_rates[] = {
2258         44100, 48000
2259 };
2260
2261 static const unsigned long long ni_value[] = {
2262         3528, 768
2263 };
2264
2265 static const unsigned long long mi_value[] = {
2266         8125, 1625
2267 };
2268
2269 static void max98090_configure_bclk(struct snd_soc_codec *codec)
2270 {
2271         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2272         unsigned long long ni;
2273         int i;
2274
2275         if (!max98090->sysclk) {
2276                 dev_dbg(codec->dev, "No SYSCLK configured\n");
2277                 return;
2278         }
2279
2280         if (!max98090->bclk || !max98090->lrclk) {
2281                 dev_dbg(codec->dev, "No audio clocks configured\n");
2282                 return;
2283         }
2284
2285         /* Skip configuration when operating as slave */
2286         if (!(snd_soc_read(codec, M98090_REG_21_CLOCK_MAS_MODE) &
2287                 M98090_CLK_MAS_MASK)) {
2288                 return;
2289         }
2290
2291         /* Check for supported PCLK to LRCLK ratios */
2292         for (i = 0; i < ARRAY_SIZE(pclk_rates); i++) {
2293                 if ((pclk_rates[i] == max98090->sysclk) &&
2294                         (lrclk_rates[i] == max98090->lrclk)) {
2295                         dev_info(codec->dev,
2296                                 "Found supported PCLK to LRCLK rates 0x%x\n",
2297                                 i + 0x8);
2298
2299                         snd_soc_update_bits(codec, M98090_REG_1C_CLOCK_MODE,
2300                                 M98090_CLK_FREQ1_MASK, (i + 0x8) <<
2301                                 M98090_CLK_FREQ1_SHIFT);
2302                         snd_soc_update_bits(codec, M98090_REG_1C_CLOCK_MODE,
2303                                 M98090_CLK_USE_M1_MASK, 0);
2304                         return;
2305                 }
2306         }
2307
2308         /* Check for user calculated MI and NI ratios */
2309         for (i = 0; i < ARRAY_SIZE(user_pclk_rates); i++) {
2310                 if ((user_pclk_rates[i] == max98090->sysclk) &&
2311                         (user_lrclk_rates[i] == max98090->lrclk)) {
2312                         dev_info(codec->dev,
2313                                 "Found user supported PCLK to LRCLK rates\n");
2314                         dev_info(codec->dev, "i %d ni %lld mi %lld\n",
2315                                 i, ni_value[i], mi_value[i]);
2316
2317                         snd_soc_update_bits(codec, M98090_REG_1C_CLOCK_MODE,
2318                                 M98090_CLK_FREQ1_MASK, 0);
2319                         snd_soc_update_bits(codec, M98090_REG_1C_CLOCK_MODE,
2320                                 M98090_CLK_USE_M1_MASK,
2321                                 1 << M98090_CLK_USE_M1_SHIFT);
2322
2323                         snd_soc_write(codec, M98090_REG_1D_CLOCK_DAI1_NI_HI,
2324                                 (ni_value[i] >> 8) & 0x7F);
2325                         snd_soc_write(codec, M98090_REG_1E_CLOCK_DAI2_NI_LO,
2326                                 ni_value[i] & 0xFF);
2327                         snd_soc_write(codec, M98090_REG_1F_CLOCK_DAI3_MI_HI,
2328                                 (mi_value[i] >> 8) & 0x7F);
2329                         snd_soc_write(codec, M98090_REG_20_CLOCK_DAI4_MI_LO,
2330                                 mi_value[i] & 0xFF);
2331
2332                         return;
2333                 }
2334         }
2335
2336         /*
2337          * Calculate based on MI = 65536
2338          * (not as good as either method above)
2339          */
2340         snd_soc_update_bits(codec, M98090_REG_1C_CLOCK_MODE,
2341                 M98090_CLK_FREQ1_MASK, 0);
2342         snd_soc_update_bits(codec, M98090_REG_1C_CLOCK_MODE,
2343                 M98090_CLK_USE_M1_MASK, 0);
2344
2345         /* Configure NI when operating as master
2346          * Note: There is a small, but significant audio quality improvement
2347          * by calculating ni and mi.
2348          */
2349         ni = 65536ULL * (max98090->lrclk < 50000 ? 96ULL : 48ULL)
2350                         * (unsigned long long int)max98090->lrclk;
2351         do_div(ni, (unsigned long long int)max98090->sysclk);
2352         dev_info(codec->dev, "No better method found\n");
2353         dev_info(codec->dev, "Calculating ni %lld with mi 65536\n", ni);
2354         snd_soc_write(codec, M98090_REG_1D_CLOCK_DAI1_NI_HI,
2355                         (ni >> 8) & 0x7F);
2356         snd_soc_write(codec, M98090_REG_1E_CLOCK_DAI2_NI_LO, ni & 0xFF);
2357 }
2358
2359 static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
2360                                  unsigned int fmt)
2361 {
2362         struct snd_soc_codec *codec = codec_dai->codec;
2363         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2364         struct max98090_cdata *cdata;
2365         u8 regval = 0;
2366
2367         max98090->dai_fmt = fmt;
2368         cdata = &max98090->dai[0];
2369
2370         if (fmt != cdata->fmt) {
2371                 cdata->fmt = fmt;
2372
2373                 regval = 0;
2374                 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
2375                 case SND_SOC_DAIFMT_CBS_CFS:
2376                         /* Set to slave mode PLL - MAS mode off */
2377                         snd_soc_write(codec,
2378                                 M98090_REG_1D_CLOCK_DAI1_NI_HI, 0x00);
2379                         snd_soc_write(codec,
2380                                 M98090_REG_1E_CLOCK_DAI2_NI_LO, 0x00);
2381                         snd_soc_update_bits(codec, M98090_REG_1C_CLOCK_MODE,
2382                                 M98090_CLK_USE_M1_MASK, 0);
2383                         break;
2384                 case SND_SOC_DAIFMT_CBM_CFM:
2385                         /* Set to master mode */
2386                         if (max98090->tdm_slots == 4) {
2387                                 /* TDM */
2388                                 regval |= M98090_CLK_MAS_MASK |
2389                                         M98090_CLK_BSEL_64;
2390                         } else if (max98090->tdm_slots == 3) {
2391                                 /* TDM */
2392                                 regval |= M98090_CLK_MAS_MASK |
2393                                         M98090_CLK_BSEL_48;
2394                         } else {
2395                                 /* Few TDM slots, or No TDM */
2396                                 regval |= M98090_CLK_MAS_MASK |
2397                                          M98090_CLK_BSEL_64;
2398                         }
2399                         break;
2400                 case SND_SOC_DAIFMT_CBS_CFM:
2401                 case SND_SOC_DAIFMT_CBM_CFS:
2402                 default:
2403                         dev_err(codec->dev, "DAI clock mode unsupported");
2404                         return -EINVAL;
2405                 }
2406                 snd_soc_write(codec, M98090_REG_21_CLOCK_MAS_MODE, regval);
2407
2408                 regval = 0;
2409                 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
2410                 case SND_SOC_DAIFMT_I2S:
2411                         regval |= M98090_DAI_DLY_MASK;
2412                         break;
2413                 case SND_SOC_DAIFMT_LEFT_J:
2414                         break;
2415                 case SND_SOC_DAIFMT_RIGHT_J:
2416                         regval |= M98090_DAI_RJ_MASK;
2417                         break;
2418                 case SND_SOC_DAIFMT_DSP_A:
2419                         /* Not supported mode */
2420                 default:
2421                         dev_err(codec->dev, "DAI format unsupported");
2422                         return -EINVAL;
2423                 }
2424
2425                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
2426                 case SND_SOC_DAIFMT_NB_NF:
2427                         break;
2428                 case SND_SOC_DAIFMT_NB_IF:
2429                         regval |= M98090_DAI_WCI_MASK;
2430                         break;
2431                 case SND_SOC_DAIFMT_IB_NF:
2432                         regval |= M98090_DAI_BCI_MASK;
2433                         break;
2434                 case SND_SOC_DAIFMT_IB_IF:
2435                         regval |= M98090_DAI_BCI_MASK|M98090_DAI_WCI_MASK;
2436                         break;
2437                 default:
2438                         dev_err(codec->dev, "DAI invert mode unsupported");
2439                         return -EINVAL;
2440                 }
2441
2442                 snd_soc_write(codec, M98090_REG_22_DAI_INTERFACE_FORMAT,
2443                         regval);
2444         }
2445 /*
2446  * This accommodates an inverted logic in the MAX98090 chip for
2447  * Bit Clock Invert (BCI). The inverted logic is only seen for the case
2448  * of TDM mode. The remaining cases have normal logic.
2449  */
2450         if (max98090->tdm_slots > 1) {
2451                 regval = snd_soc_read(codec, M98090_REG_21_CLOCK_MAS_MODE);
2452                 regval ^= M98090_DAI_BCI_MASK;
2453                 snd_soc_write(codec, M98090_REG_22_DAI_INTERFACE_FORMAT,
2454                 regval);
2455         }
2456
2457         return 0;
2458 }
2459
2460 static int max98090_set_tdm_slot(struct snd_soc_dai *codec_dai,
2461         unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
2462 {
2463         struct snd_soc_codec *codec = codec_dai->codec;
2464         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2465         struct max98090_cdata *cdata;
2466         cdata = &max98090->dai[0];
2467
2468         if (slots < 0 || slots > 4)
2469                 return -EINVAL;
2470
2471         max98090->tdm_slots = slots;
2472         max98090->tdm_width = slot_width;
2473
2474         if (max98090->tdm_slots > 1) {
2475                 /* SLOTL SLOTR SLOTDLY */
2476                 snd_soc_write(codec, M98090_REG_24_DAI_TDM_FORMAT,
2477                         0 << M98090_DAI_TDM_SLOTL_SHIFT |
2478                         1 << M98090_DAI_TDM_SLOTR_SHIFT |
2479                         0 << M98090_DAI_TDM_SLOTDLY_SHIFT);
2480
2481                 /* FSW TDM */
2482                 snd_soc_update_bits(codec, M98090_REG_23_DAI_TDM_CONTROL,
2483                         M98090_DAI_TDM_MASK,
2484                         M98090_DAI_TDM_MASK);
2485         }
2486
2487         /*
2488          * Normally advisable to set TDM first,
2489          * but this permits either order
2490          */
2491         cdata->fmt = 0;
2492         max98090_dai_set_fmt(codec_dai, max98090->dai_fmt);
2493
2494         return 0;
2495 }
2496
2497 static int max98090_set_bias_level(struct snd_soc_codec *codec,
2498                                    enum snd_soc_bias_level level)
2499 {
2500         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2501         int ret;
2502
2503         switch (level) {
2504         case SND_SOC_BIAS_ON:
2505                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
2506                         ret = snd_soc_cache_sync(codec);
2507
2508                         if (ret != 0) {
2509                                 dev_err(codec->dev,
2510                                         "Failed to sync cache: %d\n", ret);
2511                                 return ret;
2512                         }
2513                 }
2514
2515                 if (max98090->jack_state == M98090_JACK_STATE_HEADSET) {
2516                         /*
2517                          * Set to normal bias level.
2518                          */
2519                         snd_soc_update_bits(codec, M98090_REG_12_MIC_BIAS,
2520                                 M98090_MBVSEL_MASK, M98090_MBVSEL_2V4);
2521
2522                         snd_soc_update_bits(codec, M98090_REG_3E_PWR_EN_IN,
2523                                 M98090_PWR_MBEN_MASK, M98090_PWR_MBEN_MASK);
2524                 }
2525                 break;
2526
2527         case SND_SOC_BIAS_PREPARE:
2528                 break;
2529
2530         case SND_SOC_BIAS_STANDBY:
2531                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
2532                         ret = snd_soc_cache_sync(codec);
2533                         if (ret != 0) {
2534                                 dev_err(codec->dev,
2535                                         "Failed to sync cache: %d\n", ret);
2536                                 return ret;
2537                         }
2538                 }
2539                 break;
2540
2541         case SND_SOC_BIAS_OFF:
2542                 snd_soc_update_bits(codec, M98090_REG_3E_PWR_EN_IN,
2543                         M98090_PWR_MBEN_MASK, 0);
2544                 /* Set internal pull-up to lowest power mode */
2545                 snd_soc_update_bits(codec, M98090_REG_3D_CFG_JACK,
2546                         M98090_JDWK_MASK, M98090_JDWK_MASK);
2547                 codec->cache_sync = 1;
2548                 break;
2549         }
2550         codec->dapm.bias_level = level;
2551         return 0;
2552 }
2553
2554 static const int comp_pclk_rates[] = {
2555         11289600, 12288000, 12000000, 13000000, 19200000
2556 };
2557
2558 static const int dmic_micclk[] = {
2559         2, 2, 2, 2, 4, 2
2560 };
2561
2562 static const int comp_lrclk_rates[] = {
2563         8000, 16000, 32000, 44100, 48000, 96000
2564 };
2565
2566 static const int dmic_comp[6][6] = {
2567         {7, 8, 3, 3, 3, 3},
2568         {7, 8, 3, 3, 3, 3},
2569         {7, 8, 3, 3, 3, 3},
2570         {7, 8, 3, 1, 1, 1},
2571         {7, 8, 3, 1, 2, 2},
2572         {7, 8, 3, 3, 3, 3}
2573 };
2574
2575 static int max98090_dai_hw_params(struct snd_pcm_substream *substream,
2576                                    struct snd_pcm_hw_params *params,
2577                                    struct snd_soc_dai *dai)
2578 {
2579         struct snd_soc_codec *codec = dai->codec;
2580         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2581         struct max98090_cdata *cdata;
2582         int i, j;
2583
2584         cdata = &max98090->dai[0];
2585         max98090->bclk = snd_soc_params_to_bclk(params);
2586         if (params_channels(params) == 1)
2587                 max98090->bclk *= 2;
2588
2589         max98090->lrclk = params_rate(params);
2590
2591         switch (params_format(params)) {
2592         case SNDRV_PCM_FORMAT_S16_LE:
2593                 snd_soc_update_bits(codec, M98090_REG_22_DAI_INTERFACE_FORMAT,
2594                         M98090_DAI_WS_MASK, 0);
2595                 break;
2596         case SNDRV_PCM_FORMAT_S24_LE:
2597                 snd_soc_update_bits(codec, M98090_REG_22_DAI_INTERFACE_FORMAT,
2598                         M98090_DAI_WS_MASK, 2);
2599                 break;
2600         default:
2601                 return -EINVAL;
2602         }
2603
2604         max98090_configure_bclk(codec);
2605
2606         cdata->rate = max98090->lrclk;
2607
2608         /* Update filter mode */
2609         if (max98090->lrclk < 24000) {
2610                 snd_soc_update_bits(codec, M98090_REG_26_DAI_FILTERS,
2611                         M98090_DAI_FLT_MODE_MASK, 0);
2612         } else {
2613                 snd_soc_update_bits(codec, M98090_REG_26_DAI_FILTERS,
2614                         M98090_DAI_FLT_MODE_MASK, M98090_DAI_FLT_MODE_MASK);
2615         }
2616
2617         /* Update sample rate mode */
2618         if (max98090->lrclk < 50000)
2619                 snd_soc_update_bits(codec, M98090_REG_26_DAI_FILTERS,
2620                         M98090_DAI_FLT_DHF_MASK, 0);
2621         else
2622                 snd_soc_update_bits(codec, M98090_REG_26_DAI_FILTERS,
2623                         M98090_DAI_FLT_DHF_MASK, M98090_DAI_FLT_DHF_MASK);
2624
2625         /* Check for supported PCLK to LRCLK ratios */
2626         for (j = 0; j < ARRAY_SIZE(comp_pclk_rates); j++) {
2627                 if (comp_pclk_rates[j] == max98090->sysclk)
2628                         break;
2629         }
2630
2631         for (i = 0; i < ARRAY_SIZE(comp_lrclk_rates) - 1; i++) {
2632                 if (max98090->lrclk <= (comp_lrclk_rates[i] +
2633                         comp_lrclk_rates[i + 1]) / 2) {
2634                         break;
2635                 }
2636         }
2637
2638         snd_soc_update_bits(codec, M98090_REG_13_MIC_CFG1,
2639                         M98090_MICCLK_MASK,
2640                         dmic_micclk[j] << M98090_MICCLK_SHIFT);
2641
2642         snd_soc_update_bits(codec, M98090_REG_14_MIC_CFG2,
2643                         M98090_DMIC_COMP_MASK,
2644                         dmic_comp[j][i] << M98090_DMIC_COMP_SHIFT);
2645
2646         return 0;
2647 }
2648
2649 /*
2650  * PLL / Sysclk
2651  */
2652 static int max98090_dai_set_sysclk(struct snd_soc_dai *dai,
2653                                    int clk_id, unsigned int freq, int dir)
2654 {
2655         struct snd_soc_codec *codec = dai->codec;
2656         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2657
2658         /* Requested clock frequency is already setup */
2659         if (freq == max98090->sysclk)
2660                 return 0;
2661
2662         /* Setup clocks for slave mode, and using the PLL
2663          * PSCLK = 0x01 (when master clk is 10MHz to 20MHz)
2664          *               0x02 (when master clk is 20MHz to 40MHz)..
2665          *               0x03 (when master clk is 40MHz to 60MHz)..
2666          */
2667         if ((freq >= 10000000) && (freq < 20000000)) {
2668                 snd_soc_write(codec, M98090_REG_1B_SYS_CLOCK,
2669                         M98090_CLK_PSCLK_DIV1);
2670         } else if ((freq >= 20000000) && (freq < 40000000)) {
2671                 snd_soc_write(codec, M98090_REG_1B_SYS_CLOCK,
2672                         M98090_CLK_PSCLK_DIV2);
2673         } else if ((freq >= 40000000) && (freq < 60000000)) {
2674                 snd_soc_write(codec, M98090_REG_1B_SYS_CLOCK,
2675                         M98090_CLK_PSCLK_DIV4);
2676         } else {
2677                 dev_err(codec->dev, "Invalid master clock frequency\n");
2678                 return -EINVAL;
2679         }
2680
2681         max98090->sysclk = freq;
2682
2683         max98090_configure_bclk(codec);
2684
2685         return 0;
2686 }
2687
2688 static int max98090_dai_digital_mute(struct snd_soc_dai *codec_dai, int mute)
2689 {
2690         struct snd_soc_codec *codec = codec_dai->codec;
2691         int regval;
2692
2693         regval = mute ? M98090_DAI_LVL_DVM_MASK : 0;
2694         snd_soc_update_bits(codec, M98090_REG_27_DAI_LVL,
2695                 M98090_DAI_LVL_DVM_MASK, regval);
2696
2697         return 0;
2698 }
2699
2700 static void max98090_dmic_switch(struct snd_soc_codec *codec, int state)
2701 {
2702         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2703         struct max98090_pdata *pdata = max98090->pdata;
2704         u8 regval = 0;
2705
2706         dev_info(codec->dev,
2707                 "max98090_dmic_switch state=%d left=%d right=%d\n",
2708                 state, pdata->digmic_left_mode, pdata->digmic_right_mode);
2709
2710         if (state) {
2711                 /* Configure mic for analog/digital mic mode */
2712                 if (pdata->digmic_left_mode)
2713                         regval |= M98090_DIGMICL_MASK;
2714
2715                 if (pdata->digmic_right_mode)
2716                         regval |= M98090_DIGMICR_MASK;
2717
2718                 if (max98090->devtype == MAX98091) {
2719                         if (pdata->digmic_3_mode)
2720                                 regval |= M98090_DIGMIC3_MASK;
2721
2722                         if (pdata->digmic_4_mode)
2723                                 regval |= M98090_DIGMIC4_MASK;
2724                 }
2725
2726                 if (regval) {
2727                         /*
2728                          * Different default setup of DMIC can go here:
2729                          *  M98090_REG_13_MIC_CFG1
2730                          *  M98090_REG_14_MIC_CFG2
2731                          */
2732
2733                         snd_soc_update_bits(codec, M98090_REG_26_DAI_FILTERS,
2734                                 M98090_DAI_FLT_AHPF_MASK,
2735                                 M98090_DAI_FLT_AHPF_MASK);
2736                 }
2737
2738         } else {
2739                 snd_soc_update_bits(codec, M98090_REG_26_DAI_FILTERS,
2740                         M98090_DAI_FLT_AHPF_MASK, 0);
2741         }
2742
2743         snd_soc_update_bits(codec, M98090_REG_13_MIC_CFG1,
2744                         M98090_DIGMIC4_MASK | M98090_DIGMIC3_MASK |
2745                         M98090_DIGMICR_MASK | M98090_DIGMICL_MASK,
2746                         regval);
2747 }
2748
2749 static void max98090_headset_button_event(struct snd_soc_codec *codec)
2750 {
2751         dev_info(codec->dev, "max98090_headset_button_event\n");
2752 }
2753
2754 static void max98090_jack_work(struct work_struct *work)
2755 {
2756         struct max98090_priv *max98090 = container_of(work,
2757                 struct max98090_priv,
2758                 jack_work.work);
2759         struct snd_soc_codec *codec = max98090->codec;
2760         int reg;
2761
2762         /* Read a second time */
2763         if (max98090->jack_state == M98090_JACK_STATE_NO_HEADSET) {
2764
2765                 snd_soc_update_bits(codec, M98090_REG_3E_PWR_EN_IN,
2766                         M98090_PWR_MBEN_MASK, 0);
2767
2768                 /* Strong pull up allows mic detection */
2769                 snd_soc_update_bits(codec, M98090_REG_3D_CFG_JACK,
2770                         M98090_JDWK_MASK, 0);
2771
2772                 msleep(50);
2773
2774                 reg = snd_soc_read(codec, M98090_REG_02_JACK_STATUS);
2775
2776                 /* Weak pull up allows only insertion detection */
2777                 snd_soc_update_bits(codec, M98090_REG_3D_CFG_JACK,
2778                         M98090_JDWK_MASK, M98090_JDWK_MASK);
2779         } else {
2780                 reg = snd_soc_read(codec, M98090_REG_02_JACK_STATUS);
2781         }
2782
2783         reg = snd_soc_read(codec, M98090_REG_02_JACK_STATUS);
2784
2785         switch (reg & (M98090_LSNS_MASK | M98090_JKSNS_MASK)) {
2786         case M98090_LSNS_MASK | M98090_JKSNS_MASK:
2787                 {
2788                         dev_info(codec->dev, "No Headset Detected\n");
2789
2790                         max98090->jack_state = M98090_JACK_STATE_NO_HEADSET;
2791
2792                         max98090_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
2793
2794                         snd_soc_dapm_disable_pin(&codec->dapm, "HPL");
2795                         snd_soc_dapm_disable_pin(&codec->dapm, "HPR");
2796                         snd_soc_dapm_force_enable_pin(&codec->dapm, "SPKL");
2797                         snd_soc_dapm_force_enable_pin(&codec->dapm, "SPKR");
2798                         snd_soc_dapm_disable_pin(&codec->dapm, "MIC1");
2799                         snd_soc_dapm_disable_pin(&codec->dapm, "MIC2");
2800                         snd_soc_dapm_force_enable_pin(&codec->dapm, "DMICL");
2801                         snd_soc_dapm_force_enable_pin(&codec->dapm, "DMICR");
2802                         max98090_dmic_switch(codec, 1);
2803
2804                         break;
2805                 }
2806
2807         case 0:
2808                 {
2809                         if (max98090->jack_state ==
2810                                 M98090_JACK_STATE_HEADSET) {
2811
2812                                 dev_info(codec->dev,
2813                                         "Headset Button Down Detected\n");
2814
2815                                 max98090_headset_button_event(codec);
2816
2817                                 return;
2818                         }
2819
2820                         /* Line is reported as Headphone */
2821                         /* Nokia Headset is reported as Headphone */
2822                         /* Mono Headphone is reported as Headphone */
2823                         dev_info(codec->dev, "Headphone Detected\n");
2824
2825                         max98090->jack_state = M98090_JACK_STATE_HEADPHONE;
2826
2827                         max98090_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
2828
2829                         snd_soc_dapm_disable_pin(&codec->dapm, "SPKL");
2830                         snd_soc_dapm_disable_pin(&codec->dapm, "SPKR");
2831                         snd_soc_dapm_force_enable_pin(&codec->dapm, "HPL");
2832                         snd_soc_dapm_force_enable_pin(&codec->dapm, "HPR");
2833                         snd_soc_dapm_disable_pin(&codec->dapm, "MIC1");
2834                         snd_soc_dapm_disable_pin(&codec->dapm, "MIC2");
2835                         snd_soc_dapm_force_enable_pin(&codec->dapm, "DMICL");
2836                         snd_soc_dapm_force_enable_pin(&codec->dapm, "DMICR");
2837                         max98090_dmic_switch(codec, 1);
2838
2839                         break;
2840                 }
2841
2842         case M98090_JKSNS_MASK:
2843                 {
2844                         dev_info(codec->dev, "Headset Detected\n");
2845
2846                         max98090->jack_state = M98090_JACK_STATE_HEADSET;
2847
2848                         max98090_set_bias_level(codec, SND_SOC_BIAS_ON);
2849
2850                         snd_soc_dapm_disable_pin(&codec->dapm, "SPKL");
2851                         snd_soc_dapm_disable_pin(&codec->dapm, "SPKR");
2852                         snd_soc_dapm_force_enable_pin(&codec->dapm, "HPL");
2853                         snd_soc_dapm_force_enable_pin(&codec->dapm, "HPR");
2854                         snd_soc_dapm_disable_pin(&codec->dapm, "DMICL");
2855                         snd_soc_dapm_disable_pin(&codec->dapm, "DMICR");
2856                         snd_soc_dapm_force_enable_pin(&codec->dapm, "MIC1");
2857                         snd_soc_dapm_force_enable_pin(&codec->dapm, "MIC2");
2858                         max98090_dmic_switch(codec, 0);
2859
2860                         break;
2861                 }
2862
2863         default:
2864                 {
2865                         dev_info(codec->dev, "Unrecognized Jack Status\n");
2866                         break;
2867                 }
2868         }
2869 }
2870
2871 static irqreturn_t max98090_interrupt(int irq, void *data)
2872 {
2873         struct snd_soc_codec *codec = data;
2874         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
2875         unsigned int mask;
2876         unsigned int active;
2877
2878         dev_info(codec->dev, "***** max98090_interrupt *****\n");
2879
2880         mask = snd_soc_read(codec, M98090_REG_03_IRQ_ENABLE);
2881         active = snd_soc_read(codec, M98090_REG_01_IRQ_STATUS);
2882
2883         dev_info(codec->dev, "active=0x%02x mask=0x%02x -> active=0x%02x\n",
2884                 active, mask, active & mask);
2885
2886         active &= mask;
2887
2888         if (!active)
2889                 return IRQ_NONE;
2890
2891         /* Send work to be scheduled */
2892         if (active & M98090_IRQ_CLD_MASK)
2893                 dev_info(codec->dev, "M98090_IRQ_CLD_MASK\n");
2894
2895         if (active & M98090_IRQ_SLD_MASK)
2896                 dev_info(codec->dev, "M98090_IRQ_SLD_MASK\n");
2897
2898         if (active & M98090_IRQ_ULK_MASK)
2899                 dev_info(codec->dev, "M98090_IRQ_ULK_MASK\n");
2900
2901         if (active & M98090_IRQ_JDET_MASK) {
2902                 dev_info(codec->dev, "M98090_IRQ_JDET_MASK\n");
2903
2904 /*              trace_snd_soc_jack_irq(dev_name(dev)); */
2905
2906                 pm_wakeup_event(codec->dev, 100);
2907
2908                 schedule_delayed_work(&max98090->jack_work,
2909                         msecs_to_jiffies(100));
2910         }
2911
2912         if (active & M98090_IRQ_ALCACT_MASK)
2913                 dev_info(codec->dev, "M98090_IRQ_ALCACT_MASK\n");
2914
2915         if (active & M98090_IRQ_ALCCLP_MASK)
2916                 dev_info(codec->dev, "M98090_IRQ_ALCCLP_MASK\n");
2917
2918         return IRQ_HANDLED;
2919 }
2920
2921
2922 #define MAX98090_RATES SNDRV_PCM_RATE_8000_96000
2923 #define MAX98090_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE)
2924
2925 static struct snd_soc_dai_ops max98090_dai_ops = {
2926         .set_sysclk = max98090_dai_set_sysclk,
2927         .set_fmt = max98090_dai_set_fmt,
2928         .set_tdm_slot = max98090_set_tdm_slot,
2929         .hw_params = max98090_dai_hw_params,
2930         .digital_mute = max98090_dai_digital_mute,
2931 };
2932
2933 static struct snd_soc_dai_driver max98090_dai[] = {
2934 {
2935         .name = "HiFi",
2936         .playback = {
2937                 .stream_name = "HiFi Playback",
2938                 .channels_min = 2,
2939                 .channels_max = 2,
2940                 .rates = MAX98090_RATES,
2941                 .formats = MAX98090_FORMATS,
2942         },
2943         .capture = {
2944                 .stream_name = "HiFi Capture",
2945                 .channels_min = 1,
2946                 .channels_max = 2,
2947                 .rates = MAX98090_RATES,
2948                 .formats = MAX98090_FORMATS,
2949         },
2950          .ops = &max98090_dai_ops,
2951 }
2952 };
2953
2954 /*
2955  * Equalizer filter coefs generated from the MAXIM MAX98090
2956  * Evaluation Kit (EVKIT) software tool
2957  */
2958 static struct max98090_eq_cfg eq_cfg[] = {
2959         { /* Flat response */
2960         .name = "FLAT",
2961         .rate = 48000,
2962         .bands = 7,
2963         .coef = {
2964                 0x00, 0x00, 0x00,
2965                 0x00, 0x00, 0x00,
2966                 0x10, 0x00, 0x00,
2967                 0x00, 0x00, 0x00,
2968                 0x00, 0x00, 0x00,
2969
2970                 0x00, 0x00, 0x00,
2971                 0x00, 0x00, 0x00,
2972                 0x10, 0x00, 0x00,
2973                 0x00, 0x00, 0x00,
2974                 0x00, 0x00, 0x00,
2975
2976                 0x00, 0x00, 0x00,
2977                 0x00, 0x00, 0x00,
2978                 0x10, 0x00, 0x00,
2979                 0x00, 0x00, 0x00,
2980                 0x00, 0x00, 0x00,
2981
2982                 0x00, 0x00, 0x00,
2983                 0x00, 0x00, 0x00,
2984                 0x10, 0x00, 0x00,
2985                 0x00, 0x00, 0x00,
2986                 0x00, 0x00, 0x00,
2987
2988                 0x00, 0x00, 0x00,
2989                 0x00, 0x00, 0x00,
2990                 0x10, 0x00, 0x00,
2991                 0x00, 0x00, 0x00,
2992                 0x00, 0x00, 0x00,
2993
2994                 0x00, 0x00, 0x00,
2995                 0x00, 0x00, 0x00,
2996                 0x10, 0x00, 0x00,
2997                 0x00, 0x00, 0x00,
2998                 0x00, 0x00, 0x00,
2999
3000                 0x00, 0x00, 0x00,
3001                 0x00, 0x00, 0x00,
3002                 0x10, 0x00, 0x00,
3003                 0x00, 0x00, 0x00,
3004                 0x00, 0x00, 0x00,
3005                 },
3006         },
3007         { /* Low pass Fc=4KHz */
3008         .name = "LOWPASS",
3009         .rate = 48000,
3010         .bands = 7,
3011         .coef = {
3012                 0xC2, 0x51, 0x87,
3013                 0xB2, 0x46, 0xD4,
3014                 0xED, 0x09, 0x65,
3015                 0xC2, 0x51, 0x87,
3016                 0xD5, 0x3D, 0x70,
3017
3018                 0xF3, 0x6A, 0xD6,
3019                 0xE3, 0x62, 0x32,
3020                 0xFF, 0x5B, 0x1E,
3021                 0xF3, 0x6A, 0xD6,
3022                 0xF4, 0x07, 0x14,
3023
3024                 0xC2, 0x51, 0x87,
3025                 0xB2, 0x46, 0xD4,
3026                 0xED, 0x09, 0x65,
3027                 0xC2, 0x51, 0x87,
3028                 0xD5, 0x3D, 0x70,
3029
3030                 0xC2, 0x51, 0x87,
3031                 0xB2, 0x46, 0xD4,
3032                 0xED, 0x09, 0x65,
3033                 0xC2, 0x51, 0x87,
3034                 0xD5, 0x3D, 0x70,
3035
3036                 0xC2, 0x51, 0x87,
3037                 0xB2, 0x46, 0xD4,
3038                 0xED, 0x09, 0x65,
3039                 0xC2, 0x51, 0x87,
3040                 0xD5, 0x3D, 0x70,
3041
3042                 0xC2, 0x51, 0x87,
3043                 0xB2, 0x46, 0xD4,
3044                 0xED, 0x09, 0x65,
3045                 0xC2, 0x51, 0x87,
3046                 0xD5, 0x3D, 0x70,
3047
3048                 0xC2, 0x51, 0x87,
3049                 0xB2, 0x46, 0xD4,
3050                 0xED, 0x09, 0x65,
3051                 0xC2, 0x51, 0x87,
3052                 0xD5, 0x3D, 0x70,
3053                 },
3054         },
3055         { /* Bass and Treble compensation for -30dB volume */
3056         .name = "SMARTVOL",
3057         .rate = 48000,
3058         .bands = 7,
3059         .coef = {
3060                 0xE0, 0x0D, 0x96,
3061                 0x0F, 0xF2, 0x71,
3062                 0x10, 0x09, 0xFD,
3063                 0xE0, 0x0D, 0x96,
3064                 0x0F, 0xE8, 0x74,
3065
3066                 0xE0, 0x3B, 0x3C,
3067                 0x0F, 0xC4, 0xDD,
3068                 0x0F, 0xF7, 0x00,
3069                 0xE0, 0x3B, 0x3C,
3070                 0x0F, 0xCD, 0xDC,
3071
3072                 0xE0, 0x41, 0x8B,
3073                 0x0F, 0xBE, 0x7D,
3074                 0x10, 0x62, 0x24,
3075                 0xE0, 0x41, 0x8B,
3076                 0x0F, 0x5C, 0x58,
3077
3078                 0xE0, 0x34, 0x76,
3079                 0x0F, 0xCB, 0x91,
3080                 0x10, 0x07, 0x71,
3081                 0xE0, 0x34, 0x76,
3082                 0x0F, 0xC4, 0x1F,
3083
3084                 0xE1, 0x44, 0xA2,
3085                 0x0E, 0xBF, 0x1F,
3086                 0x0F, 0xDA, 0x84,
3087                 0xE1, 0x44, 0xA2,
3088                 0x0E, 0xE4, 0x9B,
3089
3090                 0xF5, 0xCA, 0x0A,
3091                 0xE5, 0xCA, 0x0A,
3092                 0x18, 0x1C, 0x9F,
3093                 0xF5, 0xCA, 0x0A,
3094                 0xDD, 0xAD, 0x6B,
3095
3096                 0xEB, 0x83, 0x70,
3097                 0x08, 0x44, 0x1A,
3098                 0x0F, 0xD8, 0xE1,
3099                 0xEB, 0x83, 0x70,
3100                 0x08, 0x6B, 0x38,
3101                 },
3102         },
3103 };
3104
3105 static struct max98090_biquad_cfg bq_cfg[] = {
3106         {
3107         .name = "FLAT",
3108         .rate = 48000,
3109         .coef = {
3110                 0xE0, 0x12, 0x89,
3111                 0x0F, 0xEE, 0x2A,
3112                 0x10, 0x00, 0x00,
3113                 0xE0, 0x12, 0x89,
3114                 0x0F, 0xEE, 0x2A,
3115                 },
3116         },
3117         {
3118         .name = "LOWPASS",
3119         .rate = 48000,
3120         .coef = {
3121                 0x06, 0x5B, 0x0E,
3122                 0xF6, 0x5C, 0x2A,
3123                 0x06, 0x6A, 0xE7,
3124                 0x06, 0x5B, 0x0E,
3125                 0xFF, 0xF1, 0x42,
3126                 },
3127         },
3128 };
3129
3130 static struct max98090_biquad_cfg dmic34bq_cfg[] = {
3131         {
3132         .name = "FLAT",
3133         .rate = 48000,
3134         .coef = {
3135                 0xE0, 0x12, 0x89,
3136                 0x0F, 0xEE, 0x2A,
3137                 0x10, 0x00, 0x00,
3138                 0xE0, 0x12, 0x89,
3139                 0x0F, 0xEE, 0x2A,
3140                 },
3141         },
3142         {
3143         .name = "LOWPASS",
3144         .rate = 48000,
3145         .coef = {
3146                 0x06, 0x5B, 0x0E,
3147                 0xF6, 0x5C, 0x2A,
3148                 0x06, 0x6A, 0xE7,
3149                 0x06, 0x5B, 0x0E,
3150                 0xFF, 0xF1, 0x42,
3151                 },
3152         },
3153 };
3154
3155 static int max98090_write_eq_data(struct snd_soc_codec *codec, int config)
3156 {
3157         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3158         struct max98090_pdata *pdata = max98090->pdata;
3159         struct max98090_cdata *cdata;
3160         struct max98090_eq_cfg *coef_set;
3161         int i;
3162         int regmask, regsave;
3163         int num_bands;
3164         u8 *coefs;
3165         unsigned int reg;
3166
3167         cdata = &max98090->dai[0];
3168
3169         coef_set = &pdata->eq_cfg[config];
3170
3171         regmask = M98090_EQ3BANDEN_MASK |
3172                           M98090_EQ5BANDEN_MASK |
3173                           M98090_EQ7BANDEN_MASK;
3174
3175         num_bands = coef_set->bands;
3176         if (num_bands > 7)
3177                 return -EINVAL;
3178
3179         /* Disable filter while configuring, and save current on/off state */
3180         regsave = snd_soc_read(codec, M98090_REG_41_DSP_EQ_EN);
3181         snd_soc_update_bits(codec, M98090_REG_41_DSP_EQ_EN, regmask, 0);
3182
3183         /* Load equalizer DSP coefficient configurations registers.
3184          * Expected sequence is: B0, B1, B2, A1, A2
3185          * Each coef is 3 bytes in the register order of [23:16] [15:8] [7:0]
3186          */
3187         coefs = coef_set->coef;
3188         reg = M98090_REG_46_EQ_BASE;
3189         for (i = 0; i < M98090_COEFS_BLK_SZ * num_bands; i++)
3190                 snd_soc_write(codec, reg++, coefs[i]);
3191
3192         /* Restore the original on/off state */
3193         snd_soc_update_bits(codec, M98090_REG_41_DSP_EQ_EN, regmask, regsave);
3194
3195         return 0;
3196 }
3197
3198 static int max98090_put_eq_enum(struct snd_kcontrol *kcontrol,
3199                                  struct snd_ctl_elem_value *ucontrol)
3200 {
3201         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3202         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3203         struct max98090_pdata *pdata = max98090->pdata;
3204         struct max98090_cdata *cdata;
3205         int sel = ucontrol->value.integer.value[0];
3206         struct max98090_eq_cfg *coef_set;
3207         int fs, best, best_val, i;
3208         int num_bands;
3209
3210         cdata = &max98090->dai[0];
3211
3212         if (sel >= pdata->eq_cfgcnt)
3213                 return -EINVAL;
3214
3215         cdata->eq_sel = sel;
3216
3217         if (!pdata || !max98090->eq_textcnt)
3218                 return 0;
3219
3220         fs = cdata->rate;
3221
3222         /* Find the selected configuration with nearest sample rate */
3223         best = 0;
3224         best_val = INT_MAX;
3225         for (i = 0; i < pdata->eq_cfgcnt; i++) {
3226                 if (strcmp(pdata->eq_cfg[i].name,
3227                         max98090->eq_texts[sel]) == 0 &&
3228                         abs(pdata->eq_cfg[i].rate - fs) < best_val) {
3229                         best = i;
3230                         best_val = abs(pdata->eq_cfg[i].rate - fs);
3231                 }
3232         }
3233
3234         dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n",
3235                 pdata->eq_cfg[best].name,
3236                 pdata->eq_cfg[best].rate, fs);
3237
3238         coef_set = &pdata->eq_cfg[best];
3239
3240         num_bands = coef_set->bands;
3241         if (num_bands > 7)
3242                 return -EINVAL;
3243
3244         /* Remember the current number of bands in the current preset so that
3245          * the EQ Switch can activate the correct EQ band operating mode
3246          */
3247         cdata->eq_num_bands = num_bands;
3248
3249         max98090_write_eq_data(codec, best);
3250
3251         return 0;
3252 }
3253
3254 static int max98090_get_eq_enum(struct snd_kcontrol *kcontrol,
3255                                  struct snd_ctl_elem_value *ucontrol)
3256 {
3257         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3258         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3259         struct max98090_cdata *cdata;
3260
3261         cdata = &max98090->dai[0];
3262         ucontrol->value.enumerated.item[0] = cdata->eq_sel;
3263
3264         return 0;
3265 }
3266
3267 static void max98090_handle_eq_pdata(struct snd_soc_codec *codec)
3268 {
3269         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3270         struct max98090_pdata *pdata = max98090->pdata;
3271         struct max98090_eq_cfg *cfg;
3272         unsigned int cfgcnt;
3273         int i, j;
3274         const char **t;
3275         int ret;
3276
3277         struct snd_kcontrol_new controls[] = {
3278                 SOC_ENUM_EXT("EQ Mode",
3279                         max98090->eq_enum,
3280                         max98090_get_eq_enum,
3281                         max98090_put_eq_enum),
3282         };
3283
3284         cfg = pdata->eq_cfg;
3285         cfgcnt = pdata->eq_cfgcnt;
3286
3287         /* Setup an array of texts for the equalizer enum.
3288          */
3289         max98090->eq_textcnt = 0;
3290         max98090->eq_texts = NULL;
3291         for (i = 0; i < cfgcnt; i++) {
3292                 for (j = 0; j < max98090->eq_textcnt; j++) {
3293                         if (strcmp(cfg[i].name, max98090->eq_texts[j]) == 0)
3294                                 break;
3295                 }
3296
3297                 if (j != max98090->eq_textcnt)
3298                         continue;
3299
3300                 /* Expand the array */
3301                 t = krealloc(max98090->eq_texts,
3302                                  sizeof(char *) * (max98090->eq_textcnt + 1),
3303                                  GFP_KERNEL);
3304                 if (t == NULL)
3305                         continue;
3306
3307                 /* Store the new entry */
3308                 t[max98090->eq_textcnt] = cfg[i].name;
3309                 max98090->eq_textcnt++;
3310                 max98090->eq_texts = t;
3311         }
3312
3313         /* Now point the soc_enum to .texts array items */
3314         max98090->eq_enum.texts = max98090->eq_texts;
3315         max98090->eq_enum.max = max98090->eq_textcnt;
3316
3317         ret = snd_soc_add_codec_controls(codec, controls,
3318                         ARRAY_SIZE(controls));
3319         if (ret != 0)
3320                 dev_err(codec->dev, "Failed to add EQ control: %d\n", ret);
3321 }
3322
3323 static int max98090_write_bq_data(struct snd_soc_codec *codec, int config)
3324 {
3325         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3326         struct max98090_pdata *pdata = max98090->pdata;
3327         struct max98090_biquad_cfg *coef_set;
3328         int i;
3329         int regsave;
3330         u8 *coefs;
3331         unsigned int reg;
3332
3333         coef_set = &pdata->bq_cfg[config];
3334
3335         /* Disable filter while configuring, and save current on/off state */
3336         regsave = snd_soc_read(codec, M98090_REG_41_DSP_EQ_EN);
3337         snd_soc_update_bits(codec, M98090_REG_41_DSP_EQ_EN,
3338                         M98090_ADCBQEN_MASK, 0);
3339
3340         /* Load equalizer DSP coefficient configurations registers.
3341          * Expected sequence is: B0, B1, B2, A1, A2
3342          * Each coef is 3 bytes in the register order of [23:16] [15:8] [7:0]
3343          */
3344         coefs = coef_set->coef;
3345         reg = M98090_REG_AF_BIQUAD_BASE;
3346         for (i = 0; i < M98090_COEFS_BLK_SZ; i++)
3347                 snd_soc_write(codec, reg++, coefs[i]);
3348
3349         /* Restore the original on/off state */
3350         snd_soc_update_bits(codec, M98090_REG_41_DSP_EQ_EN,
3351                         M98090_ADCBQEN_MASK, regsave);
3352
3353         return 0;
3354 }
3355
3356 static int max98090_put_bq_enum(struct snd_kcontrol *kcontrol,
3357                                  struct snd_ctl_elem_value *ucontrol)
3358 {
3359         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3360         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3361         struct max98090_pdata *pdata = max98090->pdata;
3362         struct max98090_cdata *cdata;
3363         int sel = ucontrol->value.integer.value[0];
3364         int fs, best, best_val, i;
3365
3366         cdata = &max98090->dai[0];
3367
3368         if (sel >= pdata->bq_cfgcnt)
3369                 return -EINVAL;
3370
3371         cdata->bq_sel = sel;
3372
3373         if (!pdata || !max98090->bq_textcnt)
3374                 return 0;
3375
3376         fs = cdata->rate;
3377
3378         /* Find the selected configuration with nearest sample rate */
3379         best = 0;
3380         best_val = INT_MAX;
3381         for (i = 0; i < pdata->bq_cfgcnt; i++) {
3382                 if (strcmp(pdata->bq_cfg[i].name,
3383                         max98090->bq_texts[sel]) == 0 &&
3384                         abs(pdata->bq_cfg[i].rate - fs) < best_val) {
3385                         best = i;
3386                         best_val = abs(pdata->bq_cfg[i].rate - fs);
3387                 }
3388         }
3389
3390         dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n",
3391                 pdata->bq_cfg[best].name,
3392                 pdata->bq_cfg[best].rate, fs);
3393
3394         max98090_write_bq_data(codec, best);
3395
3396         return 0;
3397 }
3398
3399 static int max98090_get_bq_enum(struct snd_kcontrol *kcontrol,
3400                                  struct snd_ctl_elem_value *ucontrol)
3401 {
3402         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3403         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3404         struct max98090_cdata *cdata;
3405
3406         cdata = &max98090->dai[0];
3407         ucontrol->value.enumerated.item[0] = cdata->bq_sel;
3408
3409         return 0;
3410 }
3411
3412 static void max98090_handle_bq_pdata(struct snd_soc_codec *codec)
3413 {
3414         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3415         struct max98090_pdata *pdata = max98090->pdata;
3416         struct max98090_biquad_cfg *cfg;
3417         unsigned int cfgcnt;
3418         int i, j;
3419         const char **t;
3420         int ret;
3421
3422         struct snd_kcontrol_new controls[] = {
3423                 SOC_ENUM_EXT("Biquad Mode",
3424                         max98090->bq_enum,
3425                         max98090_get_bq_enum,
3426                         max98090_put_bq_enum),
3427         };
3428
3429         cfg = pdata->bq_cfg;
3430         cfgcnt = pdata->bq_cfgcnt;
3431
3432         /* Setup an array of texts for the biquad enum.
3433          * This is based on Mark Brown's equalizer driver code.
3434          */
3435         max98090->bq_textcnt = 0;
3436         max98090->bq_texts = NULL;
3437         for (i = 0; i < cfgcnt; i++) {
3438                 for (j = 0; j < max98090->bq_textcnt; j++) {
3439                         if (strcmp(cfg[i].name, max98090->bq_texts[j]) == 0)
3440                                 break;
3441                 }
3442
3443                 if (j != max98090->bq_textcnt)
3444                         continue;
3445
3446                 /* Expand the array */
3447                 t = krealloc(max98090->bq_texts,
3448                                  sizeof(char *) * (max98090->bq_textcnt + 1),
3449                                  GFP_KERNEL);
3450                 if (t == NULL)
3451                         continue;
3452
3453                 /* Store the new entry */
3454                 t[max98090->bq_textcnt] = cfg[i].name;
3455                 max98090->bq_textcnt++;
3456                 max98090->bq_texts = t;
3457         }
3458
3459         /* Now point the soc_enum to .texts array items */
3460         max98090->bq_enum.texts = max98090->bq_texts;
3461         max98090->bq_enum.max = max98090->bq_textcnt;
3462
3463         ret = snd_soc_add_codec_controls(codec, controls,
3464                         ARRAY_SIZE(controls));
3465         if (ret != 0)
3466                 dev_err(codec->dev, "Failed to add Biquad control: %d\n", ret);
3467 }
3468
3469 static int max98090_write_dmic34bq_data(struct snd_soc_codec *codec,
3470                 int config)
3471 {
3472         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3473         struct max98090_pdata *pdata = max98090->pdata;
3474         struct max98090_biquad_cfg *coef_set;
3475         int i;
3476         int regsave;
3477         u8 *coefs;
3478         unsigned int reg;
3479
3480         coef_set = &pdata->dmic34bq_cfg[config];
3481
3482         /* Disable filter while configuring, and save current on/off state */
3483         regsave = snd_soc_read(codec, M98090_REG_41_DSP_EQ_EN);
3484         snd_soc_update_bits(codec, M98090_REG_41_DSP_EQ_EN,
3485                         M98090_DMIC34BQEN_MASK, 0);
3486
3487         /* Load equalizer DSP coefficient configurations registers.
3488          * Expected sequence is: B0, B1, B2, A1, A2
3489          * Each coef is 3 bytes in the register order of [23:16] [15:8] [7:0]
3490          */
3491         coefs = coef_set->coef;
3492         reg = M98090_REG_C3_DMIC34_BIQUAD_BASE;
3493         for (i = 0; i < M98090_COEFS_BLK_SZ; i++)
3494                 snd_soc_write(codec, reg++, coefs[i]);
3495
3496         /* Restore the original on/off state */
3497         snd_soc_update_bits(codec, M98090_REG_41_DSP_EQ_EN,
3498                         M98090_DMIC34BQEN_MASK, regsave);
3499
3500         return 0;
3501 }
3502
3503 static int max98090_put_dmic34bq_enum(struct snd_kcontrol *kcontrol,
3504                                  struct snd_ctl_elem_value *ucontrol)
3505 {
3506         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3507         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3508         struct max98090_pdata *pdata = max98090->pdata;
3509         struct max98090_cdata *cdata;
3510         int sel = ucontrol->value.integer.value[0];
3511         int fs, best, best_val, i;
3512
3513         cdata = &max98090->dai[0];
3514
3515         if (sel >= pdata->dmic34bq_cfgcnt)
3516                 return -EINVAL;
3517
3518         cdata->dmic34bq_sel = sel;
3519
3520         if (!pdata || !max98090->dmic34bq_textcnt)
3521                 return 0;
3522
3523         fs = cdata->rate;
3524
3525         /* Find the selected configuration with nearest sample rate */
3526         best = 0;
3527         best_val = INT_MAX;
3528         for (i = 0; i < pdata->dmic34bq_cfgcnt; i++) {
3529                 if (strcmp(pdata->dmic34bq_cfg[i].name,
3530                                 max98090->dmic34bq_texts[sel]) == 0 &&
3531                         abs(pdata->dmic34bq_cfg[i].rate - fs) < best_val) {
3532                         best = i;
3533                         best_val = abs(pdata->dmic34bq_cfg[i].rate - fs);
3534                 }
3535         }
3536
3537         dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n",
3538                 pdata->dmic34bq_cfg[best].name,
3539                 pdata->dmic34bq_cfg[best].rate, fs);
3540
3541         max98090_write_dmic34bq_data(codec, best);
3542
3543         return 0;
3544 }
3545
3546 static int max98090_get_dmic34bq_enum(struct snd_kcontrol *kcontrol,
3547                                  struct snd_ctl_elem_value *ucontrol)
3548 {
3549         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3550         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3551         struct max98090_cdata *cdata;
3552
3553         cdata = &max98090->dai[0];
3554         ucontrol->value.enumerated.item[0] = cdata->dmic34bq_sel;
3555
3556         return 0;
3557 }
3558
3559 static void max98090_handle_dmic34bq_pdata(struct snd_soc_codec *codec)
3560 {
3561         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3562         struct max98090_pdata *pdata = max98090->pdata;
3563         struct max98090_biquad_cfg *cfg;
3564         unsigned int cfgcnt;
3565         int i, j;
3566         const char **t;
3567         int ret;
3568
3569         struct snd_kcontrol_new controls[] = {
3570                 SOC_ENUM_EXT("DMIC34 Biquad Mode",
3571                         max98090->dmic34bq_enum,
3572                         max98090_get_dmic34bq_enum,
3573                         max98090_put_dmic34bq_enum),
3574         };
3575
3576         cfg = pdata->dmic34bq_cfg;
3577         cfgcnt = pdata->dmic34bq_cfgcnt;
3578
3579         /* Setup an array of texts for the biquad enum.
3580          * This is based on Mark Brown's equalizer driver code.
3581          */
3582         max98090->dmic34bq_textcnt = 0;
3583         max98090->dmic34bq_texts = NULL;
3584         for (i = 0; i < cfgcnt; i++) {
3585                 for (j = 0; j < max98090->dmic34bq_textcnt; j++) {
3586                         if (strcmp(cfg[i].name,
3587                                 max98090->dmic34bq_texts[j]) == 0)
3588                                 break;
3589                 }
3590
3591                 if (j != max98090->dmic34bq_textcnt)
3592                         continue;
3593
3594                 /* Expand the array */
3595                 t = krealloc(max98090->dmic34bq_texts,
3596                                  sizeof(char *) *
3597                                  (max98090->dmic34bq_textcnt + 1),
3598                                  GFP_KERNEL);
3599                 if (t == NULL)
3600                         continue;
3601
3602                 /* Store the new entry */
3603                 t[max98090->dmic34bq_textcnt] = cfg[i].name;
3604                 max98090->dmic34bq_textcnt++;
3605                 max98090->dmic34bq_texts = t;
3606         }
3607
3608         /* Now point the soc_enum to .texts array items */
3609         max98090->dmic34bq_enum.texts = max98090->dmic34bq_texts;
3610         max98090->dmic34bq_enum.max = max98090->dmic34bq_textcnt;
3611
3612         ret = snd_soc_add_codec_controls(codec, controls,
3613                                          ARRAY_SIZE(controls));
3614         if (ret != 0)
3615                 dev_err(codec->dev,
3616                         "Failed to add DMIC34 Biquad control: %d\n", ret);
3617 }
3618
3619 static void max98090_handle_pdata(struct snd_soc_codec *codec)
3620 {
3621         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3622         struct max98090_pdata *pdata = max98090->pdata;
3623
3624         if (!pdata) {
3625                 struct device_node *np = codec->dev->of_node;
3626                 int digmic_left_mode = 0;
3627                 int digmic_right_mode = 0;
3628
3629                 pdata = max98090->pdata = devm_kzalloc(codec->dev,
3630                                 sizeof(struct max98090_pdata),  GFP_KERNEL);
3631                 if (!max98090->pdata) {
3632                         dev_err(codec->dev, "no mmemory for platform data\n");
3633                         return;
3634                 }
3635
3636                 pdata->eq_cfg = devm_kzalloc(codec->dev,
3637                                 sizeof(struct max98090_eq_cfg), GFP_KERNEL);
3638                 if (!pdata->eq_cfg) {
3639                         dev_err(codec->dev, "no mmemory for platform data\n");
3640                         return;
3641                 }
3642
3643                 of_property_read_u32(np, "maxim,digmic-left-mode",
3644                                 &digmic_left_mode);
3645                 of_property_read_u32(np, "maxim,digmic-right-mode",
3646                                 &digmic_right_mode);
3647                 pdata->digmic_left_mode = digmic_left_mode;
3648                 pdata->digmic_right_mode = digmic_right_mode;
3649         }
3650
3651         max98090_dmic_switch(codec, 1);
3652
3653         pdata->eq_cfg = eq_cfg;
3654         pdata->eq_cfgcnt = ARRAY_SIZE(eq_cfg);
3655         pdata->bq_cfg = bq_cfg;
3656         pdata->bq_cfgcnt = ARRAY_SIZE(bq_cfg);
3657         pdata->dmic34bq_cfg = dmic34bq_cfg;
3658         pdata->dmic34bq_cfgcnt = ARRAY_SIZE(dmic34bq_cfg);
3659
3660         /* Configure equalizer */
3661         if (pdata->eq_cfgcnt) {
3662                 max98090_handle_eq_pdata(codec);
3663                 max98090_write_eq_data(codec, 0);
3664         }
3665
3666         /* Configure bi-quad filters */
3667         if (pdata->bq_cfgcnt) {
3668                 max98090_handle_bq_pdata(codec);
3669                 max98090_write_bq_data(codec, 0);
3670         }
3671
3672         /* Configure DMIC34 bi-quad filters */
3673         if ((max98090->devtype == MAX98091) &&
3674                 (pdata->dmic34bq_cfgcnt)) {
3675                 max98090_handle_dmic34bq_pdata(codec);
3676                 max98090_write_dmic34bq_data(codec, 0);
3677         }
3678 }
3679
3680 static int max98090_suspend(struct snd_soc_codec *codec)
3681 {
3682         /* Note: All are taken care of by SHDN and VCM DAPM widgets */
3683         return 0;
3684 }
3685
3686 static int max98090_resume(struct snd_soc_codec *codec)
3687 {
3688         snd_soc_cache_sync(codec);
3689         return 0;
3690 }
3691
3692 #define MAX98090_HIGH_PERFORMANCE
3693
3694 static int max98090_probe(struct snd_soc_codec *codec)
3695 {
3696         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3697         struct max98090_pdata *pdata = max98090->pdata;
3698         struct max98090_cdata *cdata;
3699         struct device_node *np = NULL;
3700         int audio_int = 0;
3701         int ret = 0;
3702
3703         dev_info(codec->dev, "max98090_probe\n");
3704
3705         if (pdata && pdata->irq)
3706                 audio_int = pdata->irq;
3707         else {
3708                 np = codec->dev->of_node;
3709                 of_property_read_u32(np, "maxim,audio-int", &audio_int);
3710         }
3711
3712         max98090->irq = audio_int;
3713         max98090->codec = codec;
3714
3715         codec->dapm.idle_bias_off = 1;
3716         codec->cache_sync = 1;
3717
3718         ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C);
3719         if (ret != 0) {
3720                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
3721                 return ret;
3722         }
3723
3724         /* Reset the codec, the DSP core, and disable all interrupts */
3725         max98090_reset(codec);
3726
3727         /* Initialize private data */
3728
3729         max98090->sysclk = (unsigned)-1;
3730         max98090->eq_textcnt = 0;
3731         max98090->bq_textcnt = 0;
3732
3733         cdata = &max98090->dai[0];
3734         cdata->rate = (unsigned)-1;
3735         cdata->fmt  = (unsigned)-1;
3736         cdata->eq_sel = 0;
3737         cdata->bq_sel = 0;
3738         cdata->dmic34bq_sel = 0;
3739
3740         max98090->lin_state = 0;
3741         max98090->mic1pre = 0;
3742         max98090->mic2pre = 0;
3743         max98090->extmic_mux = 0;
3744
3745         ret = snd_soc_read(codec, M98090_REG_FF_REV_ID);
3746         if (ret < 0) {
3747                 dev_err(codec->dev, "Failed to read device revision: %d\n",
3748                         ret);
3749                 goto err_access;
3750         }
3751
3752         if ((ret >= M98090_REVA) && (ret <= M98090_REVA + 0x0f)) {
3753                 max98090->devtype = MAX98090;
3754                 dev_info(codec->dev, "MAX98090 REVID=0x%02x\n", ret);
3755         } else if ((ret >= M98091_REVA) && (ret <= M98091_REVA + 0x0f)) {
3756                 max98090->devtype = MAX98091;
3757                 dev_info(codec->dev, "MAX98091 REVID=0x%02x\n", ret);
3758         } else {
3759                 max98090->devtype = MAX98090;
3760                 dev_err(codec->dev, "Unrecognized revision 0x%02x\n", ret);
3761         }
3762
3763         max98090->jack_state = M98090_JACK_STATE_NO_HEADSET;
3764
3765         INIT_DELAYED_WORK(&max98090->jack_work, max98090_jack_work);
3766
3767         max98090_handle_pdata(codec);
3768
3769 #ifdef MAX98090_HIGH_PERFORMANCE
3770         /* High Performance */
3771         snd_soc_update_bits(codec, M98090_REG_43_DAC_CFG,
3772                 M98090_DACHP_MASK,
3773                 1 << M98090_DACHP_SHIFT);
3774         snd_soc_update_bits(codec, M98090_REG_43_DAC_CFG,
3775                 M98090_DAC_PERFMODE_MASK,
3776                 0 << M98090_DAC_PERFMODE_SHIFT);
3777         snd_soc_update_bits(codec, M98090_REG_44_ADC_CFG,
3778                 M98090_ADCHP_MASK,
3779                 1 << M98090_ADCHP_SHIFT);
3780 #else
3781         /* Low Power */
3782         snd_soc_update_bits(codec, M98090_REG_43_DAC_CFG,
3783                 M98090_DACHP_MASK,
3784                 0 << M98090_DACHP_SHIFT);
3785         snd_soc_update_bits(codec, M98090_REG_43_DAC_CFG,
3786                 M98090_DAC_PERFMODE_MASK,
3787                 1 << M98090_DAC_PERFMODE_SHIFT);
3788         snd_soc_update_bits(codec, M98090_REG_44_ADC_CFG,
3789                 M98090_ADCHP_MASK,
3790                 0 << M98090_ADCHP_SHIFT);
3791 #endif /* MAX98090_HIGH_PERFORMANCE */
3792
3793         /* Turn on VCM bandgap reference */
3794         snd_soc_write(codec, M98090_REG_42_BIAS_CNTL,
3795                 M98090_VCM_MODE_MASK);
3796
3797         max98090_add_widgets(codec);
3798
3799         /* Clear existing interrupts */
3800         snd_soc_read(codec, M98090_REG_01_IRQ_STATUS);
3801
3802         /* Register for interrupts */
3803         if ((request_threaded_irq(audio_int, NULL,
3804                 max98090_interrupt, IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
3805                 "max98090_interrupt", codec)) < 0) {
3806                 dev_info(codec->dev, "request_irq failed\n");
3807         }
3808
3809         /* Enable jack detection */
3810         snd_soc_write(codec, M98090_REG_3D_CFG_JACK,
3811                 M98090_JDETEN_MASK | M98090_JDEB_25MS);
3812
3813 err_access:
3814         return ret;
3815 }
3816
3817 static int max98090_remove(struct snd_soc_codec *codec)
3818 {
3819         struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
3820
3821         free_irq(max98090->irq, codec);
3822
3823         cancel_delayed_work_sync(&max98090->jack_work);
3824
3825         kfree(max98090->bq_texts);
3826         kfree(max98090->eq_texts);
3827
3828         return 0;
3829 }
3830
3831 static struct snd_soc_codec_driver soc_codec_dev_max98090 = {
3832         .probe   = max98090_probe,
3833         .remove  = max98090_remove,
3834         .suspend = max98090_suspend,
3835         .resume  = max98090_resume,
3836         .set_bias_level = max98090_set_bias_level,
3837         .reg_cache_size = ARRAY_SIZE(max98090_reg_def),
3838         .reg_word_size = sizeof(u8),
3839         .reg_cache_default = max98090_reg_def,
3840         .readable_register = max98090_readable,
3841         .volatile_register = max98090_volatile_register,
3842 };
3843
3844 static int max98090_i2c_probe(struct i2c_client *i2c,
3845                                  const struct i2c_device_id *id)
3846 {
3847         struct max98090_priv *max98090;
3848         int ret;
3849
3850         pr_info("max98090_i2c_probe\n");
3851
3852         max98090 = kzalloc(sizeof(struct max98090_priv), GFP_KERNEL);
3853         if (max98090 == NULL)
3854                 return -ENOMEM;
3855
3856         max98090->devtype = id->driver_data;
3857         i2c_set_clientdata(i2c, max98090);
3858         max98090->control_data = i2c;
3859         max98090->pdata = i2c->dev.platform_data;
3860
3861         ret = snd_soc_register_codec(&i2c->dev,
3862                         &soc_codec_dev_max98090, max98090_dai,
3863                         ARRAY_SIZE(max98090_dai));
3864         if (ret < 0)
3865                 kfree(max98090);
3866         return ret;
3867 }
3868
3869 static int __devexit max98090_i2c_remove(struct i2c_client *client)
3870 {
3871         snd_soc_unregister_codec(&client->dev);
3872         kfree(i2c_get_clientdata(client));
3873         return 0;
3874 }
3875
3876 static const struct i2c_device_id max98090_i2c_id[] = {
3877         { "max98090", MAX98090 },
3878         { }
3879 };
3880 MODULE_DEVICE_TABLE(i2c, max98090_i2c_id);
3881
3882 static struct i2c_driver max98090_i2c_driver = {
3883         .driver = {
3884                 .name = "max98090",
3885                 .owner = THIS_MODULE,
3886         },
3887         .probe  = max98090_i2c_probe,
3888         .remove = __devexit_p(max98090_i2c_remove),
3889         .id_table = max98090_i2c_id,
3890 };
3891
3892 static int __init max98090_init(void)
3893 {
3894         int ret;
3895
3896         ret = i2c_add_driver(&max98090_i2c_driver);
3897         if (ret)
3898                 pr_err("Failed to register MAX98090 I2C driver: %d\n", ret);
3899         else
3900                 pr_info("MAX98090 driver registered\n");
3901
3902         return ret;
3903 }
3904
3905 module_init(max98090_init);
3906
3907 static void __exit max98090_exit(void)
3908 {
3909         i2c_del_driver(&max98090_i2c_driver);
3910 }
3911 module_exit(max98090_exit);
3912
3913 MODULE_DESCRIPTION("ALSA SoC MAX98090 driver");
3914 MODULE_AUTHOR("Peter Hsiang, Jesse Marroqin, Jerry Wong");
3915 MODULE_LICENSE("GPL");