2 * wm2000.c -- WM2000 ALSA Soc Audio driver
4 * Copyright 2008-2011 Wolfson Microelectronics PLC.
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
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.
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/firmware.h>
19 #include <linux/clk.h>
20 #include <linux/delay.h>
22 #include <linux/i2c.h>
23 #include <linux/regmap.h>
24 #include <linux/debugfs.h>
25 #include <linux/regulator/consumer.h>
26 #include <linux/slab.h>
27 #include <sound/core.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/soc.h>
31 #include <sound/initval.h>
32 #include <sound/tlv.h>
34 #include <sound/wm2000.h>
38 #define WM2000_NUM_SUPPLIES 3
40 static const char *wm2000_supplies[WM2000_NUM_SUPPLIES] = {
46 enum wm2000_anc_mode {
54 struct i2c_client *i2c;
55 struct regmap *regmap;
58 struct regulator_bulk_data supplies[WM2000_NUM_SUPPLIES];
60 enum wm2000_anc_mode anc_mode;
62 unsigned int anc_active:1;
63 unsigned int anc_eng_ena:1;
64 unsigned int spk_ena:1;
66 unsigned int speech_clarity:1;
68 int anc_download_size;
74 static int wm2000_write(struct i2c_client *i2c, unsigned int reg,
77 struct wm2000_priv *wm2000 = i2c_get_clientdata(i2c);
78 return regmap_write(wm2000->regmap, reg, value);
81 static unsigned int wm2000_read(struct i2c_client *i2c, unsigned int r)
83 struct wm2000_priv *wm2000 = i2c_get_clientdata(i2c);
87 ret = regmap_read(wm2000->regmap, r, &val);
94 static void wm2000_reset(struct wm2000_priv *wm2000)
96 struct i2c_client *i2c = wm2000->i2c;
98 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
99 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
100 wm2000_write(i2c, WM2000_REG_ID1, 0);
102 wm2000->anc_mode = ANC_OFF;
105 static int wm2000_poll_bit(struct i2c_client *i2c,
106 unsigned int reg, u8 mask)
111 val = wm2000_read(i2c, reg);
113 while (!(val & mask) && --timeout) {
115 val = wm2000_read(i2c, reg);
124 static int wm2000_power_up(struct i2c_client *i2c, int analogue)
126 struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
130 if (WARN_ON(wm2000->anc_mode != ANC_OFF))
133 dev_dbg(&i2c->dev, "Beginning power up\n");
135 ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies);
137 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
141 rate = clk_get_rate(wm2000->mclk);
142 if (rate <= 13500000) {
143 dev_dbg(&i2c->dev, "Disabling MCLK divider\n");
144 wm2000_write(i2c, WM2000_REG_SYS_CTL2,
145 WM2000_MCLK_DIV2_ENA_CLR);
147 dev_dbg(&i2c->dev, "Enabling MCLK divider\n");
148 wm2000_write(i2c, WM2000_REG_SYS_CTL2,
149 WM2000_MCLK_DIV2_ENA_SET);
152 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
153 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_SET);
155 /* Wait for ANC engine to become ready */
156 if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
157 WM2000_ANC_ENG_IDLE)) {
158 dev_err(&i2c->dev, "ANC engine failed to reset\n");
159 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
163 if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
164 WM2000_STATUS_BOOT_COMPLETE)) {
165 dev_err(&i2c->dev, "ANC engine failed to initialise\n");
166 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
170 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
172 /* Open code download of the data since it is the only bulk
174 dev_dbg(&i2c->dev, "Downloading %d bytes\n",
175 wm2000->anc_download_size - 2);
177 ret = i2c_master_send(i2c, wm2000->anc_download,
178 wm2000->anc_download_size);
180 dev_err(&i2c->dev, "i2c_transfer() failed: %d\n", ret);
181 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
184 if (ret != wm2000->anc_download_size) {
185 dev_err(&i2c->dev, "i2c_transfer() failed, %d != %d\n",
186 ret, wm2000->anc_download_size);
187 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
191 dev_dbg(&i2c->dev, "Download complete\n");
194 wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
196 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
197 WM2000_MODE_ANA_SEQ_INCLUDE |
198 WM2000_MODE_MOUSE_ENABLE |
199 WM2000_MODE_THERMAL_ENABLE);
201 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
202 WM2000_MODE_MOUSE_ENABLE |
203 WM2000_MODE_THERMAL_ENABLE);
206 ret = wm2000_read(i2c, WM2000_REG_SPEECH_CLARITY);
207 if (wm2000->speech_clarity)
208 ret |= WM2000_SPEECH_CLARITY;
210 ret &= ~WM2000_SPEECH_CLARITY;
211 wm2000_write(i2c, WM2000_REG_SPEECH_CLARITY, ret);
213 wm2000_write(i2c, WM2000_REG_SYS_START0, 0x33);
214 wm2000_write(i2c, WM2000_REG_SYS_START1, 0x02);
216 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
218 if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
219 WM2000_STATUS_MOUSE_ACTIVE)) {
220 dev_err(&i2c->dev, "Timed out waiting for device\n");
221 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
225 dev_dbg(&i2c->dev, "ANC active\n");
227 dev_dbg(&i2c->dev, "Analogue active\n");
228 wm2000->anc_mode = ANC_ACTIVE;
233 static int wm2000_power_down(struct i2c_client *i2c, int analogue)
235 struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
238 wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
239 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
240 WM2000_MODE_ANA_SEQ_INCLUDE |
241 WM2000_MODE_POWER_DOWN);
243 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
244 WM2000_MODE_POWER_DOWN);
247 if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
248 WM2000_STATUS_POWER_DOWN_COMPLETE)) {
249 dev_err(&i2c->dev, "Timeout waiting for ANC power down\n");
253 if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
254 WM2000_ANC_ENG_IDLE)) {
255 dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
259 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
261 dev_dbg(&i2c->dev, "powered off\n");
262 wm2000->anc_mode = ANC_OFF;
267 static int wm2000_enter_bypass(struct i2c_client *i2c, int analogue)
269 struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
271 if (WARN_ON(wm2000->anc_mode != ANC_ACTIVE))
275 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
276 WM2000_MODE_ANA_SEQ_INCLUDE |
277 WM2000_MODE_THERMAL_ENABLE |
278 WM2000_MODE_BYPASS_ENTRY);
280 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
281 WM2000_MODE_THERMAL_ENABLE |
282 WM2000_MODE_BYPASS_ENTRY);
285 if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
286 WM2000_STATUS_ANC_DISABLED)) {
287 dev_err(&i2c->dev, "Timeout waiting for ANC disable\n");
291 if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
292 WM2000_ANC_ENG_IDLE)) {
293 dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
297 wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
298 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
300 wm2000->anc_mode = ANC_BYPASS;
301 dev_dbg(&i2c->dev, "bypass enabled\n");
306 static int wm2000_exit_bypass(struct i2c_client *i2c, int analogue)
308 struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
310 if (WARN_ON(wm2000->anc_mode != ANC_BYPASS))
313 wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
316 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
317 WM2000_MODE_ANA_SEQ_INCLUDE |
318 WM2000_MODE_MOUSE_ENABLE |
319 WM2000_MODE_THERMAL_ENABLE);
321 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
322 WM2000_MODE_MOUSE_ENABLE |
323 WM2000_MODE_THERMAL_ENABLE);
326 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
327 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
329 if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
330 WM2000_STATUS_MOUSE_ACTIVE)) {
331 dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
335 wm2000->anc_mode = ANC_ACTIVE;
336 dev_dbg(&i2c->dev, "MOUSE active\n");
341 static int wm2000_enter_standby(struct i2c_client *i2c, int analogue)
343 struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
345 if (WARN_ON(wm2000->anc_mode != ANC_ACTIVE))
349 wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, 248 / 4);
351 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
352 WM2000_MODE_ANA_SEQ_INCLUDE |
353 WM2000_MODE_THERMAL_ENABLE |
354 WM2000_MODE_STANDBY_ENTRY);
356 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
357 WM2000_MODE_THERMAL_ENABLE |
358 WM2000_MODE_STANDBY_ENTRY);
361 if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
362 WM2000_STATUS_ANC_DISABLED)) {
364 "Timed out waiting for ANC disable after 1ms\n");
368 if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT, WM2000_ANC_ENG_IDLE)) {
370 "Timed out waiting for standby\n");
374 wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
375 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
377 wm2000->anc_mode = ANC_STANDBY;
378 dev_dbg(&i2c->dev, "standby\n");
380 dev_dbg(&i2c->dev, "Analogue disabled\n");
385 static int wm2000_exit_standby(struct i2c_client *i2c, int analogue)
387 struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
389 if (WARN_ON(wm2000->anc_mode != ANC_STANDBY))
392 wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
395 wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);
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);
402 wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
403 WM2000_MODE_THERMAL_ENABLE |
404 WM2000_MODE_MOUSE_ENABLE);
407 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
408 wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
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");
416 wm2000->anc_mode = ANC_ACTIVE;
417 dev_dbg(&i2c->dev, "MOUSE active\n");
419 dev_dbg(&i2c->dev, "Analogue enabled\n");
424 typedef int (*wm2000_mode_fn)(struct i2c_client *i2c, int analogue);
427 enum wm2000_anc_mode source;
428 enum wm2000_anc_mode dest;
430 wm2000_mode_fn step[2];
431 } anc_transitions[] = {
445 wm2000_enter_standby,
458 .source = ANC_ACTIVE,
466 .source = ANC_ACTIVE,
470 wm2000_enter_standby,
474 .source = ANC_ACTIVE,
482 .source = ANC_BYPASS,
490 .source = ANC_BYPASS,
495 wm2000_enter_standby,
499 .source = ANC_BYPASS,
507 .source = ANC_STANDBY,
515 .source = ANC_STANDBY,
524 .source = ANC_STANDBY,
533 static int wm2000_anc_transition(struct wm2000_priv *wm2000,
534 enum wm2000_anc_mode mode)
536 struct i2c_client *i2c = wm2000->i2c;
540 if (wm2000->anc_mode == mode)
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)
547 if (i == ARRAY_SIZE(anc_transitions)) {
548 dev_err(&i2c->dev, "No transition for %d->%d\n",
549 wm2000->anc_mode, mode);
553 /* Maintain clock while active */
554 if (anc_transitions[i].source == ANC_OFF) {
555 ret = clk_prepare_enable(wm2000->mclk);
557 dev_err(&i2c->dev, "Failed to enable MCLK: %d\n", ret);
562 for (j = 0; j < ARRAY_SIZE(anc_transitions[j].step); j++) {
563 if (!anc_transitions[i].step[j])
565 ret = anc_transitions[i].step[j](i2c,
566 anc_transitions[i].analogue);
571 if (anc_transitions[i].dest == ANC_OFF)
572 clk_disable_unprepare(wm2000->mclk);
577 static int wm2000_anc_set_mode(struct wm2000_priv *wm2000)
579 struct i2c_client *i2c = wm2000->i2c;
580 enum wm2000_anc_mode mode;
582 if (wm2000->anc_eng_ena && wm2000->spk_ena)
583 if (wm2000->anc_active)
590 dev_dbg(&i2c->dev, "Set mode %d (enabled %d, mute %d, active %d)\n",
591 mode, wm2000->anc_eng_ena, !wm2000->spk_ena,
594 return wm2000_anc_transition(wm2000, mode);
597 static int wm2000_anc_mode_get(struct snd_kcontrol *kcontrol,
598 struct snd_ctl_elem_value *ucontrol)
600 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
601 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
603 ucontrol->value.integer.value[0] = wm2000->anc_active;
608 static int wm2000_anc_mode_put(struct snd_kcontrol *kcontrol,
609 struct snd_ctl_elem_value *ucontrol)
611 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
612 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
613 unsigned int anc_active = ucontrol->value.integer.value[0];
619 mutex_lock(&wm2000->lock);
621 wm2000->anc_active = anc_active;
623 ret = wm2000_anc_set_mode(wm2000);
625 mutex_unlock(&wm2000->lock);
630 static int wm2000_speaker_get(struct snd_kcontrol *kcontrol,
631 struct snd_ctl_elem_value *ucontrol)
633 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
634 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
636 ucontrol->value.integer.value[0] = wm2000->spk_ena;
641 static int wm2000_speaker_put(struct snd_kcontrol *kcontrol,
642 struct snd_ctl_elem_value *ucontrol)
644 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
645 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
646 unsigned int val = ucontrol->value.integer.value[0];
652 mutex_lock(&wm2000->lock);
654 wm2000->spk_ena = val;
656 ret = wm2000_anc_set_mode(wm2000);
658 mutex_unlock(&wm2000->lock);
663 static const struct snd_kcontrol_new wm2000_controls[] = {
664 SOC_SINGLE("ANC Volume", WM2000_REG_ANC_GAIN_CTRL, 0, 255, 0),
665 SOC_SINGLE_BOOL_EXT("WM2000 ANC Switch", 0,
667 wm2000_anc_mode_put),
668 SOC_SINGLE_BOOL_EXT("WM2000 Switch", 0,
673 static int wm2000_anc_power_event(struct snd_soc_dapm_widget *w,
674 struct snd_kcontrol *kcontrol, int event)
676 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
677 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
680 mutex_lock(&wm2000->lock);
682 if (SND_SOC_DAPM_EVENT_ON(event))
683 wm2000->anc_eng_ena = 1;
685 if (SND_SOC_DAPM_EVENT_OFF(event))
686 wm2000->anc_eng_ena = 0;
688 ret = wm2000_anc_set_mode(wm2000);
690 mutex_unlock(&wm2000->lock);
695 static const struct snd_soc_dapm_widget wm2000_dapm_widgets[] = {
696 /* Externally visible pins */
697 SND_SOC_DAPM_OUTPUT("SPKN"),
698 SND_SOC_DAPM_OUTPUT("SPKP"),
700 SND_SOC_DAPM_INPUT("LINN"),
701 SND_SOC_DAPM_INPUT("LINP"),
703 SND_SOC_DAPM_PGA_E("ANC Engine", SND_SOC_NOPM, 0, 0, NULL, 0,
704 wm2000_anc_power_event,
705 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
708 /* Target, Path, Source */
709 static const struct snd_soc_dapm_route wm2000_audio_map[] = {
710 { "SPKN", NULL, "ANC Engine" },
711 { "SPKP", NULL, "ANC Engine" },
712 { "ANC Engine", NULL, "LINN" },
713 { "ANC Engine", NULL, "LINP" },
717 static int wm2000_suspend(struct snd_soc_codec *codec)
719 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
721 return wm2000_anc_transition(wm2000, ANC_OFF);
724 static int wm2000_resume(struct snd_soc_codec *codec)
726 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
728 return wm2000_anc_set_mode(wm2000);
731 #define wm2000_suspend NULL
732 #define wm2000_resume NULL
735 static bool wm2000_readable_reg(struct device *dev, unsigned int reg)
738 case WM2000_REG_SYS_START:
739 case WM2000_REG_ANC_GAIN_CTRL:
740 case WM2000_REG_MSE_TH1:
741 case WM2000_REG_MSE_TH2:
742 case WM2000_REG_SPEECH_CLARITY:
743 case WM2000_REG_SYS_WATCHDOG:
744 case WM2000_REG_ANA_VMID_PD_TIME:
745 case WM2000_REG_ANA_VMID_PU_TIME:
746 case WM2000_REG_CAT_FLTR_INDX:
747 case WM2000_REG_CAT_GAIN_0:
748 case WM2000_REG_SYS_STATUS:
749 case WM2000_REG_SYS_MODE_CNTRL:
750 case WM2000_REG_SYS_START0:
751 case WM2000_REG_SYS_START1:
754 case WM2000_REG_REVISON:
755 case WM2000_REG_SYS_CTL1:
756 case WM2000_REG_SYS_CTL2:
757 case WM2000_REG_ANC_STAT:
758 case WM2000_REG_IF_CTL:
759 case WM2000_REG_ANA_MIC_CTL:
760 case WM2000_REG_SPK_CTL:
767 static const struct regmap_config wm2000_regmap = {
771 .max_register = WM2000_REG_SPK_CTL,
772 .readable_reg = wm2000_readable_reg,
775 static int wm2000_probe(struct snd_soc_codec *codec)
777 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
779 /* This will trigger a transition to standby mode by default */
780 wm2000_anc_set_mode(wm2000);
785 static int wm2000_remove(struct snd_soc_codec *codec)
787 struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
789 return wm2000_anc_transition(wm2000, ANC_OFF);
792 static const struct snd_soc_codec_driver soc_codec_dev_wm2000 = {
793 .probe = wm2000_probe,
794 .remove = wm2000_remove,
795 .suspend = wm2000_suspend,
796 .resume = wm2000_resume,
798 .component_driver = {
799 .controls = wm2000_controls,
800 .num_controls = ARRAY_SIZE(wm2000_controls),
801 .dapm_widgets = wm2000_dapm_widgets,
802 .num_dapm_widgets = ARRAY_SIZE(wm2000_dapm_widgets),
803 .dapm_routes = wm2000_audio_map,
804 .num_dapm_routes = ARRAY_SIZE(wm2000_audio_map),
808 static int wm2000_i2c_probe(struct i2c_client *i2c,
809 const struct i2c_device_id *i2c_id)
811 struct wm2000_priv *wm2000;
812 struct wm2000_platform_data *pdata;
813 const char *filename;
814 const struct firmware *fw = NULL;
819 wm2000 = devm_kzalloc(&i2c->dev, sizeof(struct wm2000_priv),
824 mutex_init(&wm2000->lock);
826 dev_set_drvdata(&i2c->dev, wm2000);
828 wm2000->regmap = devm_regmap_init_i2c(i2c, &wm2000_regmap);
829 if (IS_ERR(wm2000->regmap)) {
830 ret = PTR_ERR(wm2000->regmap);
831 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
836 for (i = 0; i < WM2000_NUM_SUPPLIES; i++)
837 wm2000->supplies[i].supply = wm2000_supplies[i];
839 ret = devm_regulator_bulk_get(&i2c->dev, WM2000_NUM_SUPPLIES,
842 dev_err(&i2c->dev, "Failed to get supplies: %d\n", ret);
846 ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies);
848 dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
852 /* Verify that this is a WM2000 */
853 reg = wm2000_read(i2c, WM2000_REG_ID1);
855 reg = wm2000_read(i2c, WM2000_REG_ID2);
859 dev_err(&i2c->dev, "Device is not a WM2000 - ID %x\n", id);
864 reg = wm2000_read(i2c, WM2000_REG_REVISON);
865 dev_info(&i2c->dev, "revision %c\n", reg + 'A');
867 wm2000->mclk = devm_clk_get(&i2c->dev, "MCLK");
868 if (IS_ERR(wm2000->mclk)) {
869 ret = PTR_ERR(wm2000->mclk);
870 dev_err(&i2c->dev, "Failed to get MCLK: %d\n", ret);
874 filename = "/*(DEBLOBBED)*/";
875 pdata = dev_get_platdata(&i2c->dev);
877 wm2000->speech_clarity = !pdata->speech_enh_disable;
879 if (pdata->download_file)
880 filename = pdata->download_file;
883 ret = reject_firmware(&fw, filename, &i2c->dev);
885 dev_err(&i2c->dev, "Failed to acquire ANC data: %d\n", ret);
889 /* Pre-cook the concatenation of the register address onto the image */
890 wm2000->anc_download_size = fw->size + 2;
891 wm2000->anc_download = devm_kzalloc(&i2c->dev,
892 wm2000->anc_download_size,
894 if (wm2000->anc_download == NULL) {
895 dev_err(&i2c->dev, "Out of memory\n");
900 wm2000->anc_download[0] = 0x80;
901 wm2000->anc_download[1] = 0x00;
902 memcpy(wm2000->anc_download + 2, fw->data, fw->size);
904 wm2000->anc_eng_ena = 1;
905 wm2000->anc_active = 1;
909 wm2000_reset(wm2000);
911 ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_wm2000, NULL, 0);
914 regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
917 release_firmware(fw);
921 static int wm2000_i2c_remove(struct i2c_client *i2c)
923 snd_soc_unregister_codec(&i2c->dev);
928 static const struct i2c_device_id wm2000_i2c_id[] = {
932 MODULE_DEVICE_TABLE(i2c, wm2000_i2c_id);
934 static struct i2c_driver wm2000_i2c_driver = {
938 .probe = wm2000_i2c_probe,
939 .remove = wm2000_i2c_remove,
940 .id_table = wm2000_i2c_id,
943 module_i2c_driver(wm2000_i2c_driver);
945 MODULE_DESCRIPTION("ASoC WM2000 driver");
946 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfonmicro.com>");
947 MODULE_LICENSE("GPL");