1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
49static const char *wm2000_supplies[WM2000_NUM_SUPPLIES] = {
50 "SPKVDD",
51 "DBVDD",
52 "DCVDD",
53};
54
55enum wm2000_anc_mode {
56 ANC_ACTIVE = 0,
57 ANC_BYPASS = 1,
58 ANC_STANDBY = 2,
59 ANC_OFF = 3,
60};
61
62struct 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
81static 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
88static 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
101static 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
112static 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
131static 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
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
177
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
237static 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
271static 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
309static 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
343static 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
386static 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
424typedef int (*wm2000_mode_fn)(struct i2c_client *i2c, int analogue);
425
426static 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
533static 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
565static 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
585static 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
596static 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
611static 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
622static 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
637static 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
646static 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 = w->codec;
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
661static const struct snd_soc_dapm_widget wm2000_dapm_widgets[] = {
662
663SND_SOC_DAPM_OUTPUT("SPKN"),
664SND_SOC_DAPM_OUTPUT("SPKP"),
665
666SND_SOC_DAPM_INPUT("LINN"),
667SND_SOC_DAPM_INPUT("LINP"),
668
669SND_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
675static 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
683static 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
690static 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
701static 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
728static 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
736static int wm2000_probe(struct snd_soc_codec *codec)
737{
738 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
739
740
741 wm2000_anc_set_mode(wm2000);
742
743 return 0;
744}
745
746static 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
753static 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
767static int 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
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
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
866err_supplies:
867 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
868
869out:
870 release_firmware(fw);
871 return ret;
872}
873
874static int wm2000_i2c_remove(struct i2c_client *i2c)
875{
876 snd_soc_unregister_codec(&i2c->dev);
877
878 return 0;
879}
880
881static const struct i2c_device_id wm2000_i2c_id[] = {
882 { "wm2000", 0 },
883 { }
884};
885MODULE_DEVICE_TABLE(i2c, wm2000_i2c_id);
886
887static struct i2c_driver wm2000_i2c_driver = {
888 .driver = {
889 .name = "wm2000",
890 .owner = THIS_MODULE,
891 },
892 .probe = wm2000_i2c_probe,
893 .remove = wm2000_i2c_remove,
894 .id_table = wm2000_i2c_id,
895};
896
897module_i2c_driver(wm2000_i2c_driver);
898
899MODULE_DESCRIPTION("ASoC WM2000 driver");
900MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfonmicro.com>");
901MODULE_LICENSE("GPL");
902
