Merge tag 'sound-3.7' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
[linux-3.10.git] / sound / soc / codecs / wm2000.c
1 /*
2  * wm2000.c  --  WM2000 ALSA Soc Audio driver
3  *
4  * Copyright 2008-2011 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * The download image for the WM2000 will be requested as
13  * 'wm2000_anc.bin' by default (overridable via platform data) at
14  * runtime and is expected to be in flat binary format.  This is
15  * generated by Wolfson configuration tools and includes
16  * system-specific callibration information.  If supplied as a
17  * sequence of ASCII-encoded hexidecimal bytes this can be converted
18  * into a flat binary with a command such as this on the command line:
19  *
20  * perl -e 'while (<>) { s/[\r\n]+// ; printf("%c", hex($_)); }'
21  *                 < file  > wm2000_anc.bin
22  */
23
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/firmware.h>
29 #include <linux/delay.h>
30 #include <linux/pm.h>
31 #include <linux/i2c.h>
32 #include <linux/regmap.h>
33 #include <linux/debugfs.h>
34 #include <linux/regulator/consumer.h>
35 #include <linux/slab.h>
36 #include <sound/core.h>
37 #include <sound/pcm.h>
38 #include <sound/pcm_params.h>
39 #include <sound/soc.h>
40 #include <sound/initval.h>
41 #include <sound/tlv.h>
42
43 #include <sound/wm2000.h>
44
45 #include "wm2000.h"
46
47 #define WM2000_NUM_SUPPLIES 3
48
49 static const char *wm2000_supplies[WM2000_NUM_SUPPLIES] = {
50         "SPKVDD",
51         "DBVDD",
52         "DCVDD",
53 };
54
55 enum wm2000_anc_mode {
56         ANC_ACTIVE = 0,
57         ANC_BYPASS = 1,
58         ANC_STANDBY = 2,
59         ANC_OFF = 3,
60 };
61
62 struct wm2000_priv {
63         struct i2c_client *i2c;
64         struct regmap *regmap;
65
66         struct regulator_bulk_data supplies[WM2000_NUM_SUPPLIES];
67
68         enum wm2000_anc_mode anc_mode;
69
70         unsigned int anc_active:1;
71         unsigned int anc_eng_ena:1;
72         unsigned int spk_ena:1;
73
74         unsigned int mclk_div:1;
75         unsigned int speech_clarity:1;
76
77         int anc_download_size;
78         char *anc_download;
79 };
80
81 static int wm2000_write(struct i2c_client *i2c, unsigned int reg,
82                         unsigned int value)
83 {
84         struct wm2000_priv *wm2000 = i2c_get_clientdata(i2c);
85         return regmap_write(wm2000->regmap, reg, value);
86 }
87
88 static unsigned int wm2000_read(struct i2c_client *i2c, unsigned int r)
89 {
90         struct wm2000_priv *wm2000 = i2c_get_clientdata(i2c);
91         unsigned int val;
92         int ret;
93
94         ret = regmap_read(wm2000->regmap, r, &val);
95         if (ret < 0)
96                 return -1;
97
98         return val;
99 }
100
101 static void wm2000_reset(struct wm2000_priv *wm2000)
102 {
103         struct i2c_client *i2c = wm2000->i2c;
104
105         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
106         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
107         wm2000_write(i2c, WM2000_REG_ID1, 0);
108
109         wm2000->anc_mode = ANC_OFF;
110 }
111
112 static int wm2000_poll_bit(struct i2c_client *i2c,
113                            unsigned int reg, u8 mask)
114 {
115         int timeout = 4000;
116         int val;
117
118         val = wm2000_read(i2c, reg);
119
120         while (!(val & mask) && --timeout) {
121                 msleep(1);
122                 val = wm2000_read(i2c, reg);
123         }
124
125         if (timeout == 0)
126                 return 0;
127         else
128                 return 1;
129 }
130
131 static int wm2000_power_up(struct i2c_client *i2c, int analogue)
132 {
133         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
134         int ret;
135
136         BUG_ON(wm2000->anc_mode != ANC_OFF);
137
138         dev_dbg(&i2c->dev, "Beginning power up\n");
139
140         ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies);
141         if (ret != 0) {
142                 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
143                 return ret;
144         }
145
146         if (!wm2000->mclk_div) {
147                 dev_dbg(&i2c->dev, "Disabling MCLK divider\n");
148                 wm2000_write(i2c, WM2000_REG_SYS_CTL2,
149                              WM2000_MCLK_DIV2_ENA_CLR);
150         } else {
151                 dev_dbg(&i2c->dev, "Enabling MCLK divider\n");
152                 wm2000_write(i2c, WM2000_REG_SYS_CTL2,
153                              WM2000_MCLK_DIV2_ENA_SET);
154         }
155
156         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
157         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_SET);
158
159         /* Wait for ANC engine to become ready */
160         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
161                              WM2000_ANC_ENG_IDLE)) {
162                 dev_err(&i2c->dev, "ANC engine failed to reset\n");
163                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
164                 return -ETIMEDOUT;
165         }
166
167         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
168                              WM2000_STATUS_BOOT_COMPLETE)) {
169                 dev_err(&i2c->dev, "ANC engine failed to initialise\n");
170                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
171                 return -ETIMEDOUT;
172         }
173
174         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
175
176         /* Open code download of the data since it is the only bulk
177          * write we do. */
178         dev_dbg(&i2c->dev, "Downloading %d bytes\n",
179                 wm2000->anc_download_size - 2);
180
181         ret = i2c_master_send(i2c, wm2000->anc_download,
182                               wm2000->anc_download_size);
183         if (ret < 0) {
184                 dev_err(&i2c->dev, "i2c_transfer() failed: %d\n", ret);
185                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
186                 return ret;
187         }
188         if (ret != wm2000->anc_download_size) {
189                 dev_err(&i2c->dev, "i2c_transfer() failed, %d != %d\n",
190                         ret, wm2000->anc_download_size);
191                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
192                 return -EIO;
193         }
194
195         dev_dbg(&i2c->dev, "Download complete\n");
196
197         if (analogue) {
198                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
199
200                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
201                              WM2000_MODE_ANA_SEQ_INCLUDE |
202                              WM2000_MODE_MOUSE_ENABLE |
203                              WM2000_MODE_THERMAL_ENABLE);
204         } else {
205                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
206                              WM2000_MODE_MOUSE_ENABLE |
207                              WM2000_MODE_THERMAL_ENABLE);
208         }
209
210         ret = wm2000_read(i2c, WM2000_REG_SPEECH_CLARITY);
211         if (wm2000->speech_clarity)
212                 ret &= ~WM2000_SPEECH_CLARITY;
213         else
214                 ret |= WM2000_SPEECH_CLARITY;
215         wm2000_write(i2c, WM2000_REG_SPEECH_CLARITY, ret);
216
217         wm2000_write(i2c, WM2000_REG_SYS_START0, 0x33);
218         wm2000_write(i2c, WM2000_REG_SYS_START1, 0x02);
219
220         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
221
222         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
223                              WM2000_STATUS_MOUSE_ACTIVE)) {
224                 dev_err(&i2c->dev, "Timed out waiting for device\n");
225                 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
226                 return -ETIMEDOUT;
227         }
228
229         dev_dbg(&i2c->dev, "ANC active\n");
230         if (analogue)
231                 dev_dbg(&i2c->dev, "Analogue active\n");
232         wm2000->anc_mode = ANC_ACTIVE;
233
234         return 0;
235 }
236
237 static int wm2000_power_down(struct i2c_client *i2c, int analogue)
238 {
239         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
240
241         if (analogue) {
242                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
243                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
244                              WM2000_MODE_ANA_SEQ_INCLUDE |
245                              WM2000_MODE_POWER_DOWN);
246         } else {
247                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
248                              WM2000_MODE_POWER_DOWN);
249         }
250
251         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
252                              WM2000_STATUS_POWER_DOWN_COMPLETE)) {
253                 dev_err(&i2c->dev, "Timeout waiting for ANC power down\n");
254                 return -ETIMEDOUT;
255         }
256
257         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
258                              WM2000_ANC_ENG_IDLE)) {
259                 dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
260                 return -ETIMEDOUT;
261         }
262
263         regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
264
265         dev_dbg(&i2c->dev, "powered off\n");
266         wm2000->anc_mode = ANC_OFF;
267
268         return 0;
269 }
270
271 static int wm2000_enter_bypass(struct i2c_client *i2c, int analogue)
272 {
273         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
274
275         BUG_ON(wm2000->anc_mode != ANC_ACTIVE);
276
277         if (analogue) {
278                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
279                              WM2000_MODE_ANA_SEQ_INCLUDE |
280                              WM2000_MODE_THERMAL_ENABLE |
281                              WM2000_MODE_BYPASS_ENTRY);
282         } else {
283                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
284                              WM2000_MODE_THERMAL_ENABLE |
285                              WM2000_MODE_BYPASS_ENTRY);
286         }
287
288         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
289                              WM2000_STATUS_ANC_DISABLED)) {
290                 dev_err(&i2c->dev, "Timeout waiting for ANC disable\n");
291                 return -ETIMEDOUT;
292         }
293
294         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
295                              WM2000_ANC_ENG_IDLE)) {
296                 dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
297                 return -ETIMEDOUT;
298         }
299
300         wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
301         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
302
303         wm2000->anc_mode = ANC_BYPASS;
304         dev_dbg(&i2c->dev, "bypass enabled\n");
305
306         return 0;
307 }
308
309 static int wm2000_exit_bypass(struct i2c_client *i2c, int analogue)
310 {
311         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
312
313         BUG_ON(wm2000->anc_mode != ANC_BYPASS);
314         
315         wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
316
317         if (analogue) {
318                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
319                              WM2000_MODE_ANA_SEQ_INCLUDE |
320                              WM2000_MODE_MOUSE_ENABLE |
321                              WM2000_MODE_THERMAL_ENABLE);
322         } else {
323                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
324                              WM2000_MODE_MOUSE_ENABLE |
325                              WM2000_MODE_THERMAL_ENABLE);
326         }
327
328         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
329         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
330
331         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
332                              WM2000_STATUS_MOUSE_ACTIVE)) {
333                 dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
334                 return -ETIMEDOUT;
335         }
336
337         wm2000->anc_mode = ANC_ACTIVE;
338         dev_dbg(&i2c->dev, "MOUSE active\n");
339
340         return 0;
341 }
342
343 static int wm2000_enter_standby(struct i2c_client *i2c, int analogue)
344 {
345         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
346
347         BUG_ON(wm2000->anc_mode != ANC_ACTIVE);
348
349         if (analogue) {
350                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
351
352                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
353                              WM2000_MODE_ANA_SEQ_INCLUDE |
354                              WM2000_MODE_THERMAL_ENABLE |
355                              WM2000_MODE_STANDBY_ENTRY);
356         } else {
357                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
358                              WM2000_MODE_THERMAL_ENABLE |
359                              WM2000_MODE_STANDBY_ENTRY);
360         }
361
362         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
363                              WM2000_STATUS_ANC_DISABLED)) {
364                 dev_err(&i2c->dev,
365                         "Timed out waiting for ANC disable after 1ms\n");
366                 return -ETIMEDOUT;
367         }
368
369         if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT, WM2000_ANC_ENG_IDLE)) {
370                 dev_err(&i2c->dev,
371                         "Timed out waiting for standby\n");
372                 return -ETIMEDOUT;
373         }
374
375         wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
376         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
377
378         wm2000->anc_mode = ANC_STANDBY;
379         dev_dbg(&i2c->dev, "standby\n");
380         if (analogue)
381                 dev_dbg(&i2c->dev, "Analogue disabled\n");
382
383         return 0;
384 }
385
386 static int wm2000_exit_standby(struct i2c_client *i2c, int analogue)
387 {
388         struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
389
390         BUG_ON(wm2000->anc_mode != ANC_STANDBY);
391
392         wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
393
394         if (analogue) {
395                 wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
396
397                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
398                              WM2000_MODE_ANA_SEQ_INCLUDE |
399                              WM2000_MODE_THERMAL_ENABLE |
400                              WM2000_MODE_MOUSE_ENABLE);
401         } else {
402                 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
403                              WM2000_MODE_THERMAL_ENABLE |
404                              WM2000_MODE_MOUSE_ENABLE);
405         }
406
407         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
408         wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
409
410         if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
411                              WM2000_STATUS_MOUSE_ACTIVE)) {
412                 dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
413                 return -ETIMEDOUT;
414         }
415
416         wm2000->anc_mode = ANC_ACTIVE;
417         dev_dbg(&i2c->dev, "MOUSE active\n");
418         if (analogue)
419                 dev_dbg(&i2c->dev, "Analogue enabled\n");
420
421         return 0;
422 }
423
424 typedef int (*wm2000_mode_fn)(struct i2c_client *i2c, int analogue);
425
426 static struct {
427         enum wm2000_anc_mode source;
428         enum wm2000_anc_mode dest;
429         int analogue;
430         wm2000_mode_fn step[2];
431 } anc_transitions[] = {
432         {
433                 .source = ANC_OFF,
434                 .dest = ANC_ACTIVE,
435                 .analogue = 1,
436                 .step = {
437                         wm2000_power_up,
438                 },
439         },
440         {
441                 .source = ANC_OFF,
442                 .dest = ANC_STANDBY,
443                 .step = {
444                         wm2000_power_up,
445                         wm2000_enter_standby,
446                 },
447         },
448         {
449                 .source = ANC_OFF,
450                 .dest = ANC_BYPASS,
451                 .analogue = 1,
452                 .step = {
453                         wm2000_power_up,
454                         wm2000_enter_bypass,
455                 },
456         },
457         {
458                 .source = ANC_ACTIVE,
459                 .dest = ANC_BYPASS,
460                 .analogue = 1,
461                 .step = {
462                         wm2000_enter_bypass,
463                 },
464         },
465         {
466                 .source = ANC_ACTIVE,
467                 .dest = ANC_STANDBY,
468                 .analogue = 1,
469                 .step = {
470                         wm2000_enter_standby,
471                 },
472         },
473         {
474                 .source = ANC_ACTIVE,
475                 .dest = ANC_OFF,
476                 .analogue = 1,
477                 .step = {
478                         wm2000_power_down,
479                 },
480         },
481         {
482                 .source = ANC_BYPASS,
483                 .dest = ANC_ACTIVE,
484                 .analogue = 1,
485                 .step = {
486                         wm2000_exit_bypass,
487                 },
488         },
489         {
490                 .source = ANC_BYPASS,
491                 .dest = ANC_STANDBY,
492                 .analogue = 1,
493                 .step = {
494                         wm2000_exit_bypass,
495                         wm2000_enter_standby,
496                 },
497         },
498         {
499                 .source = ANC_BYPASS,
500                 .dest = ANC_OFF,
501                 .step = {
502                         wm2000_exit_bypass,
503                         wm2000_power_down,
504                 },
505         },
506         {
507                 .source = ANC_STANDBY,
508                 .dest = ANC_ACTIVE,
509                 .analogue = 1,
510                 .step = {
511                         wm2000_exit_standby,
512                 },
513         },
514         {
515                 .source = ANC_STANDBY,
516                 .dest = ANC_BYPASS,
517                 .analogue = 1,
518                 .step = {
519                         wm2000_exit_standby,
520                         wm2000_enter_bypass,
521                 },
522         },
523         {
524                 .source = ANC_STANDBY,
525                 .dest = ANC_OFF,
526                 .step = {
527                         wm2000_exit_standby,
528                         wm2000_power_down,
529                 },
530         },
531 };
532
533 static int wm2000_anc_transition(struct wm2000_priv *wm2000,
534                                  enum wm2000_anc_mode mode)
535 {
536         struct i2c_client *i2c = wm2000->i2c;
537         int i, j;
538         int ret;
539
540         if (wm2000->anc_mode == mode)
541                 return 0;
542
543         for (i = 0; i < ARRAY_SIZE(anc_transitions); i++)
544                 if (anc_transitions[i].source == wm2000->anc_mode &&
545                     anc_transitions[i].dest == mode)
546                         break;
547         if (i == ARRAY_SIZE(anc_transitions)) {
548                 dev_err(&i2c->dev, "No transition for %d->%d\n",
549                         wm2000->anc_mode, mode);
550                 return -EINVAL;
551         }
552
553         for (j = 0; j < ARRAY_SIZE(anc_transitions[j].step); j++) {
554                 if (!anc_transitions[i].step[j])
555                         break;
556                 ret = anc_transitions[i].step[j](i2c,
557                                                  anc_transitions[i].analogue);
558                 if (ret != 0)
559                         return ret;
560         }
561
562         return 0;
563 }
564
565 static int wm2000_anc_set_mode(struct wm2000_priv *wm2000)
566 {
567         struct i2c_client *i2c = wm2000->i2c;
568         enum wm2000_anc_mode mode;
569
570         if (wm2000->anc_eng_ena && wm2000->spk_ena)
571                 if (wm2000->anc_active)
572                         mode = ANC_ACTIVE;
573                 else
574                         mode = ANC_BYPASS;
575         else
576                 mode = ANC_STANDBY;
577
578         dev_dbg(&i2c->dev, "Set mode %d (enabled %d, mute %d, active %d)\n",
579                 mode, wm2000->anc_eng_ena, !wm2000->spk_ena,
580                 wm2000->anc_active);
581
582         return wm2000_anc_transition(wm2000, mode);
583 }
584
585 static int wm2000_anc_mode_get(struct snd_kcontrol *kcontrol,
586                                struct snd_ctl_elem_value *ucontrol)
587 {
588         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
589         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
590
591         ucontrol->value.enumerated.item[0] = wm2000->anc_active;
592
593         return 0;
594 }
595
596 static int wm2000_anc_mode_put(struct snd_kcontrol *kcontrol,
597                                struct snd_ctl_elem_value *ucontrol)
598 {
599         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
600         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
601         int anc_active = ucontrol->value.enumerated.item[0];
602
603         if (anc_active > 1)
604                 return -EINVAL;
605
606         wm2000->anc_active = anc_active;
607
608         return wm2000_anc_set_mode(wm2000);
609 }
610
611 static int wm2000_speaker_get(struct snd_kcontrol *kcontrol,
612                               struct snd_ctl_elem_value *ucontrol)
613 {
614         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
615         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
616
617         ucontrol->value.enumerated.item[0] = wm2000->spk_ena;
618
619         return 0;
620 }
621
622 static int wm2000_speaker_put(struct snd_kcontrol *kcontrol,
623                               struct snd_ctl_elem_value *ucontrol)
624 {
625         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
626         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
627         int val = ucontrol->value.enumerated.item[0];
628
629         if (val > 1)
630                 return -EINVAL;
631
632         wm2000->spk_ena = val;
633
634         return wm2000_anc_set_mode(wm2000);
635 }
636
637 static const struct snd_kcontrol_new wm2000_controls[] = {
638         SOC_SINGLE_BOOL_EXT("WM2000 ANC Switch", 0,
639                             wm2000_anc_mode_get,
640                             wm2000_anc_mode_put),
641         SOC_SINGLE_BOOL_EXT("WM2000 Switch", 0,
642                             wm2000_speaker_get,
643                             wm2000_speaker_put),
644 };
645
646 static int wm2000_anc_power_event(struct snd_soc_dapm_widget *w,
647                                   struct snd_kcontrol *kcontrol, int event)
648 {
649         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
650         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
651
652         if (SND_SOC_DAPM_EVENT_ON(event))
653                 wm2000->anc_eng_ena = 1;
654
655         if (SND_SOC_DAPM_EVENT_OFF(event))
656                 wm2000->anc_eng_ena = 0;
657
658         return wm2000_anc_set_mode(wm2000);
659 }
660
661 static const struct snd_soc_dapm_widget wm2000_dapm_widgets[] = {
662 /* Externally visible pins */
663 SND_SOC_DAPM_OUTPUT("SPKN"),
664 SND_SOC_DAPM_OUTPUT("SPKP"),
665
666 SND_SOC_DAPM_INPUT("LINN"),
667 SND_SOC_DAPM_INPUT("LINP"),
668
669 SND_SOC_DAPM_PGA_E("ANC Engine", SND_SOC_NOPM, 0, 0, NULL, 0,
670                    wm2000_anc_power_event,
671                    SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
672 };
673
674 /* Target, Path, Source */
675 static const struct snd_soc_dapm_route wm2000_audio_map[] = {
676         { "SPKN", NULL, "ANC Engine" },
677         { "SPKP", NULL, "ANC Engine" },
678         { "ANC Engine", NULL, "LINN" },
679         { "ANC Engine", NULL, "LINP" },
680 };
681
682 #ifdef CONFIG_PM
683 static int wm2000_suspend(struct snd_soc_codec *codec)
684 {
685         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
686
687         return wm2000_anc_transition(wm2000, ANC_OFF);
688 }
689
690 static int wm2000_resume(struct snd_soc_codec *codec)
691 {
692         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
693
694         return wm2000_anc_set_mode(wm2000);
695 }
696 #else
697 #define wm2000_suspend NULL
698 #define wm2000_resume NULL
699 #endif
700
701 static bool wm2000_readable_reg(struct device *dev, unsigned int reg)
702 {
703         switch (reg) {
704         case WM2000_REG_SYS_START:
705         case WM2000_REG_SPEECH_CLARITY:
706         case WM2000_REG_SYS_WATCHDOG:
707         case WM2000_REG_ANA_VMID_PD_TIME:
708         case WM2000_REG_ANA_VMID_PU_TIME:
709         case WM2000_REG_CAT_FLTR_INDX:
710         case WM2000_REG_CAT_GAIN_0:
711         case WM2000_REG_SYS_STATUS:
712         case WM2000_REG_SYS_MODE_CNTRL:
713         case WM2000_REG_SYS_START0:
714         case WM2000_REG_SYS_START1:
715         case WM2000_REG_ID1:
716         case WM2000_REG_ID2:
717         case WM2000_REG_REVISON:
718         case WM2000_REG_SYS_CTL1:
719         case WM2000_REG_SYS_CTL2:
720         case WM2000_REG_ANC_STAT:
721         case WM2000_REG_IF_CTL:
722                 return true;
723         default:
724                 return false;
725         }
726 }
727
728 static const struct regmap_config wm2000_regmap = {
729         .reg_bits = 16,
730         .val_bits = 8,
731
732         .max_register = WM2000_REG_IF_CTL,
733         .readable_reg = wm2000_readable_reg,
734 };
735
736 static int wm2000_probe(struct snd_soc_codec *codec)
737 {
738         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
739
740         /* This will trigger a transition to standby mode by default */
741         wm2000_anc_set_mode(wm2000);
742
743         return 0;
744 }
745
746 static int wm2000_remove(struct snd_soc_codec *codec)
747 {
748         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
749
750         return wm2000_anc_transition(wm2000, ANC_OFF);
751 }
752
753 static struct snd_soc_codec_driver soc_codec_dev_wm2000 = {
754         .probe = wm2000_probe,
755         .remove = wm2000_remove,
756         .suspend = wm2000_suspend,
757         .resume = wm2000_resume,
758
759         .dapm_widgets = wm2000_dapm_widgets,
760         .num_dapm_widgets = ARRAY_SIZE(wm2000_dapm_widgets),
761         .dapm_routes = wm2000_audio_map,
762         .num_dapm_routes = ARRAY_SIZE(wm2000_audio_map),
763         .controls = wm2000_controls,
764         .num_controls = ARRAY_SIZE(wm2000_controls),
765 };
766
767 static int __devinit wm2000_i2c_probe(struct i2c_client *i2c,
768                                       const struct i2c_device_id *i2c_id)
769 {
770         struct wm2000_priv *wm2000;
771         struct wm2000_platform_data *pdata;
772         const char *filename;
773         const struct firmware *fw = NULL;
774         int ret, i;
775         int reg;
776         u16 id;
777
778         wm2000 = devm_kzalloc(&i2c->dev, sizeof(struct wm2000_priv),
779                               GFP_KERNEL);
780         if (wm2000 == NULL) {
781                 dev_err(&i2c->dev, "Unable to allocate private data\n");
782                 return -ENOMEM;
783         }
784
785         dev_set_drvdata(&i2c->dev, wm2000);
786
787         wm2000->regmap = devm_regmap_init_i2c(i2c, &wm2000_regmap);
788         if (IS_ERR(wm2000->regmap)) {
789                 ret = PTR_ERR(wm2000->regmap);
790                 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
791                         ret);
792                 goto out;
793         }
794
795         for (i = 0; i < WM2000_NUM_SUPPLIES; i++)
796                 wm2000->supplies[i].supply = wm2000_supplies[i];
797
798         ret = devm_regulator_bulk_get(&i2c->dev, WM2000_NUM_SUPPLIES,
799                                       wm2000->supplies);
800         if (ret != 0) {
801                 dev_err(&i2c->dev, "Failed to get supplies: %d\n", ret);
802                 return ret;
803         }
804
805         ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies);
806         if (ret != 0) {
807                 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
808                 return ret;
809         }
810
811         /* Verify that this is a WM2000 */
812         reg = wm2000_read(i2c, WM2000_REG_ID1);
813         id = reg << 8;
814         reg = wm2000_read(i2c, WM2000_REG_ID2);
815         id |= reg & 0xff;
816
817         if (id != 0x2000) {
818                 dev_err(&i2c->dev, "Device is not a WM2000 - ID %x\n", id);
819                 ret = -ENODEV;
820                 goto err_supplies;
821         }
822
823         reg = wm2000_read(i2c, WM2000_REG_REVISON);
824         dev_info(&i2c->dev, "revision %c\n", reg + 'A');
825
826         filename = "wm2000_anc.bin";
827         pdata = dev_get_platdata(&i2c->dev);
828         if (pdata) {
829                 wm2000->mclk_div = pdata->mclkdiv2;
830                 wm2000->speech_clarity = !pdata->speech_enh_disable;
831
832                 if (pdata->download_file)
833                         filename = pdata->download_file;
834         }
835
836         ret = request_firmware(&fw, filename, &i2c->dev);
837         if (ret != 0) {
838                 dev_err(&i2c->dev, "Failed to acquire ANC data: %d\n", ret);
839                 goto err_supplies;
840         }
841
842         /* Pre-cook the concatenation of the register address onto the image */
843         wm2000->anc_download_size = fw->size + 2;
844         wm2000->anc_download = devm_kzalloc(&i2c->dev,
845                                             wm2000->anc_download_size,
846                                             GFP_KERNEL);
847         if (wm2000->anc_download == NULL) {
848                 dev_err(&i2c->dev, "Out of memory\n");
849                 ret = -ENOMEM;
850                 goto err_supplies;
851         }
852
853         wm2000->anc_download[0] = 0x80;
854         wm2000->anc_download[1] = 0x00;
855         memcpy(wm2000->anc_download + 2, fw->data, fw->size);
856
857         wm2000->anc_eng_ena = 1;
858         wm2000->anc_active = 1;
859         wm2000->spk_ena = 1;
860         wm2000->i2c = i2c;
861
862         wm2000_reset(wm2000);
863
864         ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_wm2000, NULL, 0);
865
866 err_supplies:
867         regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
868
869 out:
870         release_firmware(fw);
871         return ret;
872 }
873
874 static __devexit int wm2000_i2c_remove(struct i2c_client *i2c)
875 {
876         snd_soc_unregister_codec(&i2c->dev);
877
878         return 0;
879 }
880
881 static const struct i2c_device_id wm2000_i2c_id[] = {
882         { "wm2000", 0 },
883         { }
884 };
885 MODULE_DEVICE_TABLE(i2c, wm2000_i2c_id);
886
887 static struct i2c_driver wm2000_i2c_driver = {
888         .driver = {
889                 .name = "wm2000",
890                 .owner = THIS_MODULE,
891         },
892         .probe = wm2000_i2c_probe,
893         .remove = __devexit_p(wm2000_i2c_remove),
894         .id_table = wm2000_i2c_id,
895 };
896
897 module_i2c_driver(wm2000_i2c_driver);
898
899 MODULE_DESCRIPTION("ASoC WM2000 driver");
900 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfonmicro.com>");
901 MODULE_LICENSE("GPL");