blob: 43cf98849d0ef5c6fd2af5f70ef813e9f73c17e3 [file] [log] [blame]
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 */
12#include <linux/module.h>
13#include <linux/init.h>
Bradley Rubin229c6a52011-07-12 16:18:48 -070014#include <linux/firmware.h>
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070015#include <linux/slab.h>
16#include <linux/platform_device.h>
17#include <linux/printk.h>
18#include <linux/ratelimit.h>
Bradley Rubincb3950a2011-08-18 13:07:26 -070019#include <linux/debugfs.h>
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070020#include <linux/mfd/wcd9310/core.h>
21#include <linux/mfd/wcd9310/registers.h>
Patrick Lai3043fba2011-08-01 14:15:57 -070022#include <linux/mfd/wcd9310/pdata.h>
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070023#include <sound/jack.h>
24#include <sound/soc.h>
25#include <sound/soc-dapm.h>
26#include <sound/tlv.h>
27#include <linux/bitops.h>
28#include <linux/delay.h>
29#include "wcd9310.h"
30
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -070031#define WCD9310_RATES (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_16000|\
32 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_48000)
33
34#define NUM_DECIMATORS 10
35#define NUM_INTERPOLATORS 7
36#define BITS_PER_REG 8
37#define TABLA_RX_DAI_ID 1
38#define TABLA_TX_DAI_ID 2
39
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070040static const DECLARE_TLV_DB_SCALE(digital_gain, 0, 1, 0);
41static const DECLARE_TLV_DB_SCALE(line_gain, 0, 7, 1);
42static const DECLARE_TLV_DB_SCALE(analog_gain, 0, 25, 1);
43
44enum tabla_bandgap_type {
45 TABLA_BANDGAP_OFF = 0,
46 TABLA_BANDGAP_AUDIO_MODE,
47 TABLA_BANDGAP_MBHC_MODE,
48};
49
Bradley Rubin229c6a52011-07-12 16:18:48 -070050struct tabla_priv {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070051 struct snd_soc_codec *codec;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070052 u32 adc_count;
Patrick Lai3043fba2011-08-01 14:15:57 -070053 u32 cfilt1_cnt;
54 u32 cfilt2_cnt;
55 u32 cfilt3_cnt;
Kiran Kandi6fae8bf2011-08-15 10:36:42 -070056 u32 rx_bias_count;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070057 enum tabla_bandgap_type bandgap_type;
Kiran Kandi6fae8bf2011-08-15 10:36:42 -070058 bool mclk_enabled;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070059 bool clock_active;
60 bool config_mode_active;
61 bool mbhc_polling_active;
Bradley Rubincb1e2732011-06-23 16:49:20 -070062 int buttons_pressed;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070063
64 struct tabla_mbhc_calibration *calibration;
65
Bradley Rubincb1e2732011-06-23 16:49:20 -070066 struct snd_soc_jack *headset_jack;
67 struct snd_soc_jack *button_jack;
Bradley Rubin229c6a52011-07-12 16:18:48 -070068
Patrick Lai3043fba2011-08-01 14:15:57 -070069 struct tabla_pdata *pdata;
Bradley Rubina7096d02011-08-03 18:29:02 -070070 u32 anc_slot;
Bradley Rubincb3950a2011-08-18 13:07:26 -070071
72 bool no_mic_headset_override;
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -070073 /* Delayed work to report long button press */
74 struct delayed_work btn0_dwork;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070075};
76
Bradley Rubincb3950a2011-08-18 13:07:26 -070077#ifdef CONFIG_DEBUG_FS
78struct tabla_priv *debug_tabla_priv;
79#endif
80
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070081static int tabla_codec_enable_charge_pump(struct snd_soc_dapm_widget *w,
82 struct snd_kcontrol *kcontrol, int event)
83{
84 struct snd_soc_codec *codec = w->codec;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070085
86 pr_debug("%s %d\n", __func__, event);
87 switch (event) {
88 case SND_SOC_DAPM_POST_PMU:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070089 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL, 0x01,
90 0x01);
91 snd_soc_update_bits(codec, TABLA_A_CDC_CLSG_CTL, 0x08, 0x08);
92 usleep_range(200, 200);
93 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x10, 0x00);
94 break;
95 case SND_SOC_DAPM_PRE_PMD:
96 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_RESET_CTL, 0x10,
97 0x10);
98 usleep_range(20, 20);
99 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x08, 0x08);
100 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x10, 0x10);
101 snd_soc_update_bits(codec, TABLA_A_CDC_CLSG_CTL, 0x08, 0x00);
102 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL, 0x01,
103 0x00);
104 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x08, 0x00);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700105 break;
106 }
107 return 0;
108}
109
Bradley Rubina7096d02011-08-03 18:29:02 -0700110static int tabla_get_anc_slot(struct snd_kcontrol *kcontrol,
111 struct snd_ctl_elem_value *ucontrol)
112{
113 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
114 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
115 ucontrol->value.integer.value[0] = tabla->anc_slot;
116 return 0;
117}
118
119static int tabla_put_anc_slot(struct snd_kcontrol *kcontrol,
120 struct snd_ctl_elem_value *ucontrol)
121{
122 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
123 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
124 tabla->anc_slot = ucontrol->value.integer.value[0];
125 return 0;
126}
127
Kiran Kandid2d86b52011-09-09 17:44:28 -0700128static int tabla_pa_gain_get(struct snd_kcontrol *kcontrol,
129 struct snd_ctl_elem_value *ucontrol)
130{
131 u8 ear_pa_gain;
132 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
133
134 ear_pa_gain = snd_soc_read(codec, TABLA_A_RX_EAR_GAIN);
135
136 ear_pa_gain = ear_pa_gain >> 5;
137
138 if (ear_pa_gain == 0x00) {
139 ucontrol->value.integer.value[0] = 0;
140 } else if (ear_pa_gain == 0x04) {
141 ucontrol->value.integer.value[0] = 1;
142 } else {
143 pr_err("%s: ERROR: Unsupported Ear Gain = 0x%x\n",
144 __func__, ear_pa_gain);
145 return -EINVAL;
146 }
147
148 pr_debug("%s: ear_pa_gain = 0x%x\n", __func__, ear_pa_gain);
149
150 return 0;
151}
152
153static int tabla_pa_gain_put(struct snd_kcontrol *kcontrol,
154 struct snd_ctl_elem_value *ucontrol)
155{
156 u8 ear_pa_gain;
157 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
158
159 pr_debug("%s: ucontrol->value.integer.value[0] = %ld\n", __func__,
160 ucontrol->value.integer.value[0]);
161
162 switch (ucontrol->value.integer.value[0]) {
163 case 0:
164 ear_pa_gain = 0x00;
165 break;
166 case 1:
167 ear_pa_gain = 0x80;
168 break;
169 default:
170 return -EINVAL;
171 }
172
173 snd_soc_update_bits(codec, TABLA_A_RX_EAR_GAIN, 0xE0, ear_pa_gain);
174 return 0;
175}
176
177static const char *tabla_ear_pa_gain_text[] = {"POS_6_DB", "POS_2_DB"};
178static const struct soc_enum tabla_ear_pa_gain_enum[] = {
179 SOC_ENUM_SINGLE_EXT(2, tabla_ear_pa_gain_text),
180};
181
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700182static const struct snd_kcontrol_new tabla_snd_controls[] = {
Kiran Kandid2d86b52011-09-09 17:44:28 -0700183
184 SOC_ENUM_EXT("EAR PA Gain", tabla_ear_pa_gain_enum[0],
185 tabla_pa_gain_get, tabla_pa_gain_put),
186
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700187 SOC_SINGLE_TLV("LINEOUT1 Volume", TABLA_A_RX_LINE_1_GAIN, 0, 12, 1,
188 line_gain),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700189 SOC_SINGLE_TLV("LINEOUT2 Volume", TABLA_A_RX_LINE_2_GAIN, 0, 12, 1,
190 line_gain),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700191 SOC_SINGLE_TLV("LINEOUT3 Volume", TABLA_A_RX_LINE_3_GAIN, 0, 12, 1,
192 line_gain),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700193 SOC_SINGLE_TLV("LINEOUT4 Volume", TABLA_A_RX_LINE_4_GAIN, 0, 12, 1,
194 line_gain),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700195 SOC_SINGLE_TLV("LINEOUT5 Volume", TABLA_A_RX_LINE_5_GAIN, 0, 12, 1,
196 line_gain),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700197
198 SOC_SINGLE("RX1 CHAIN INVERT Switch", TABLA_A_CDC_RX1_B6_CTL, 4, 1, 0),
199 SOC_SINGLE("RX2 CHAIN INVERT Switch", TABLA_A_CDC_RX2_B6_CTL, 4, 1, 0),
200 SOC_SINGLE("RX3 CHAIN INVERT Switch", TABLA_A_CDC_RX3_B6_CTL, 4, 1, 0),
201 SOC_SINGLE("RX4 CHAIN INVERT Switch", TABLA_A_CDC_RX4_B6_CTL, 4, 1, 0),
202 SOC_SINGLE("RX5 CHAIN INVERT Switch", TABLA_A_CDC_RX5_B6_CTL, 4, 1, 0),
203 SOC_SINGLE("RX6 CHAIN INVERT Switch", TABLA_A_CDC_RX6_B6_CTL, 4, 1, 0),
204
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700205 SOC_SINGLE_TLV("HPHL Volume", TABLA_A_RX_HPH_L_GAIN, 0, 12, 1,
206 line_gain),
207 SOC_SINGLE_TLV("HPHR Volume", TABLA_A_RX_HPH_R_GAIN, 0, 12, 1,
208 line_gain),
209
Bradley Rubin410383f2011-07-22 13:44:23 -0700210 SOC_SINGLE_S8_TLV("RX1 Digital Volume", TABLA_A_CDC_RX1_VOL_CTL_B2_CTL,
211 -84, 40, digital_gain),
212 SOC_SINGLE_S8_TLV("RX2 Digital Volume", TABLA_A_CDC_RX2_VOL_CTL_B2_CTL,
213 -84, 40, digital_gain),
214 SOC_SINGLE_S8_TLV("RX3 Digital Volume", TABLA_A_CDC_RX3_VOL_CTL_B2_CTL,
215 -84, 40, digital_gain),
216 SOC_SINGLE_S8_TLV("RX4 Digital Volume", TABLA_A_CDC_RX4_VOL_CTL_B2_CTL,
217 -84, 40, digital_gain),
218 SOC_SINGLE_S8_TLV("RX5 Digital Volume", TABLA_A_CDC_RX5_VOL_CTL_B2_CTL,
219 -84, 40, digital_gain),
220 SOC_SINGLE_S8_TLV("RX6 Digital Volume", TABLA_A_CDC_RX6_VOL_CTL_B2_CTL,
221 -84, 40, digital_gain),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700222
Bradley Rubin410383f2011-07-22 13:44:23 -0700223 SOC_SINGLE_S8_TLV("DEC1 Volume", TABLA_A_CDC_TX1_VOL_CTL_GAIN, -84, 40,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700224 digital_gain),
Bradley Rubin410383f2011-07-22 13:44:23 -0700225 SOC_SINGLE_S8_TLV("DEC2 Volume", TABLA_A_CDC_TX2_VOL_CTL_GAIN, -84, 40,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700226 digital_gain),
Bradley Rubin410383f2011-07-22 13:44:23 -0700227 SOC_SINGLE_S8_TLV("DEC3 Volume", TABLA_A_CDC_TX3_VOL_CTL_GAIN, -84, 40,
228 digital_gain),
229 SOC_SINGLE_S8_TLV("DEC4 Volume", TABLA_A_CDC_TX4_VOL_CTL_GAIN, -84, 40,
230 digital_gain),
231 SOC_SINGLE_S8_TLV("DEC5 Volume", TABLA_A_CDC_TX5_VOL_CTL_GAIN, -84, 40,
232 digital_gain),
233 SOC_SINGLE_S8_TLV("DEC6 Volume", TABLA_A_CDC_TX6_VOL_CTL_GAIN, -84, 40,
234 digital_gain),
235 SOC_SINGLE_S8_TLV("DEC7 Volume", TABLA_A_CDC_TX7_VOL_CTL_GAIN, -84, 40,
236 digital_gain),
237 SOC_SINGLE_S8_TLV("DEC8 Volume", TABLA_A_CDC_TX8_VOL_CTL_GAIN, -84, 40,
238 digital_gain),
239 SOC_SINGLE_S8_TLV("DEC9 Volume", TABLA_A_CDC_TX9_VOL_CTL_GAIN, -84, 40,
240 digital_gain),
241 SOC_SINGLE_S8_TLV("DEC10 Volume", TABLA_A_CDC_TX10_VOL_CTL_GAIN, -84,
242 40, digital_gain),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700243
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700244 SOC_SINGLE_TLV("ADC1 Volume", TABLA_A_TX_1_2_EN, 5, 3, 0, analog_gain),
245 SOC_SINGLE_TLV("ADC2 Volume", TABLA_A_TX_1_2_EN, 1, 3, 0, analog_gain),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700246 SOC_SINGLE_TLV("ADC3 Volume", TABLA_A_TX_3_4_EN, 5, 3, 0, analog_gain),
247 SOC_SINGLE_TLV("ADC4 Volume", TABLA_A_TX_3_4_EN, 1, 3, 0, analog_gain),
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700248 SOC_SINGLE_TLV("ADC5 Volume", TABLA_A_TX_5_6_EN, 5, 3, 0, analog_gain),
249 SOC_SINGLE_TLV("ADC6 Volume", TABLA_A_TX_5_6_EN, 1, 3, 0, analog_gain),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700250
251 SOC_SINGLE("MICBIAS1 CAPLESS Switch", TABLA_A_MICB_1_CTL, 4, 1, 1),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700252 SOC_SINGLE("MICBIAS3 CAPLESS Switch", TABLA_A_MICB_3_CTL, 4, 1, 1),
253 SOC_SINGLE("MICBIAS4 CAPLESS Switch", TABLA_A_MICB_4_CTL, 4, 1, 1),
Bradley Rubina7096d02011-08-03 18:29:02 -0700254
255 SOC_SINGLE_EXT("ANC Slot", SND_SOC_NOPM, 0, 0, 100, tabla_get_anc_slot,
256 tabla_put_anc_slot),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700257};
258
259static const char *rx_mix1_text[] = {
260 "ZERO", "SRC1", "SRC2", "IIR1", "IIR2", "RX1", "RX2", "RX3", "RX4",
261 "RX5", "RX6", "RX7"
262};
263
264static const char *sb_tx1_mux_text[] = {
265 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
266 "DEC1"
267};
268
269static const char *sb_tx5_mux_text[] = {
270 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
271 "DEC5"
272};
273
274static const char *sb_tx6_mux_text[] = {
275 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
276 "DEC6"
277};
278
279static const char const *sb_tx7_to_tx10_mux_text[] = {
280 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
281 "DEC1", "DEC2", "DEC3", "DEC4", "DEC5", "DEC6", "DEC7", "DEC8",
282 "DEC9", "DEC10"
283};
284
285static const char *dec1_mux_text[] = {
286 "ZERO", "DMIC1", "ADC6",
287};
288
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700289static const char *dec2_mux_text[] = {
290 "ZERO", "DMIC2", "ADC5",
291};
292
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700293static const char *dec3_mux_text[] = {
294 "ZERO", "DMIC3", "ADC4",
295};
296
297static const char *dec4_mux_text[] = {
298 "ZERO", "DMIC4", "ADC3",
299};
300
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700301static const char *dec5_mux_text[] = {
302 "ZERO", "DMIC5", "ADC2",
303};
304
305static const char *dec6_mux_text[] = {
306 "ZERO", "DMIC6", "ADC1",
307};
308
309static const char const *dec7_mux_text[] = {
310 "ZERO", "DMIC1", "DMIC6", "ADC1", "ADC6", "ANC1_FB", "ANC2_FB",
311};
312
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700313static const char *dec8_mux_text[] = {
314 "ZERO", "DMIC2", "DMIC5", "ADC2", "ADC5",
315};
316
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700317static const char *dec9_mux_text[] = {
318 "ZERO", "DMIC4", "DMIC5", "ADC2", "ADC3", "ADCMB", "ANC1_FB", "ANC2_FB",
319};
320
321static const char *dec10_mux_text[] = {
322 "ZERO", "DMIC3", "DMIC6", "ADC1", "ADC4", "ADCMB", "ANC1_FB", "ANC2_FB",
323};
324
Bradley Rubin229c6a52011-07-12 16:18:48 -0700325static const char const *anc_mux_text[] = {
326 "ZERO", "ADC1", "ADC2", "ADC3", "ADC4", "ADC5", "ADC6", "ADC_MB",
327 "RSVD_1", "DMIC1", "DMIC2", "DMIC3", "DMIC4", "DMIC5", "DMIC6"
328};
329
330static const char const *anc1_fb_mux_text[] = {
331 "ZERO", "EAR_HPH_L", "EAR_LINE_1",
332};
333
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700334static const char *iir1_inp1_text[] = {
335 "ZERO", "DEC1", "DEC2", "DEC3", "DEC4", "DEC5", "DEC6", "DEC7", "DEC8",
336 "DEC9", "DEC10", "RX1", "RX2", "RX3", "RX4", "RX5", "RX6", "RX7"
337};
338
339static const struct soc_enum rx_mix1_inp1_chain_enum =
340 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX1_B1_CTL, 0, 12, rx_mix1_text);
341
Bradley Rubin229c6a52011-07-12 16:18:48 -0700342static const struct soc_enum rx_mix1_inp2_chain_enum =
343 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX1_B1_CTL, 4, 12, rx_mix1_text);
344
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700345static const struct soc_enum rx2_mix1_inp1_chain_enum =
346 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX2_B1_CTL, 0, 12, rx_mix1_text);
347
Bradley Rubin229c6a52011-07-12 16:18:48 -0700348static const struct soc_enum rx2_mix1_inp2_chain_enum =
349 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX2_B1_CTL, 4, 12, rx_mix1_text);
350
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700351static const struct soc_enum rx3_mix1_inp1_chain_enum =
352 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX3_B1_CTL, 0, 12, rx_mix1_text);
353
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700354static const struct soc_enum rx3_mix1_inp2_chain_enum =
355 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX3_B1_CTL, 4, 12, rx_mix1_text);
356
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700357static const struct soc_enum rx4_mix1_inp1_chain_enum =
358 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX4_B1_CTL, 0, 12, rx_mix1_text);
359
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700360static const struct soc_enum rx4_mix1_inp2_chain_enum =
361 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX4_B1_CTL, 4, 12, rx_mix1_text);
362
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700363static const struct soc_enum rx5_mix1_inp1_chain_enum =
364 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX5_B1_CTL, 0, 12, rx_mix1_text);
365
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700366static const struct soc_enum rx5_mix1_inp2_chain_enum =
367 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX5_B1_CTL, 4, 12, rx_mix1_text);
368
369static const struct soc_enum rx6_mix1_inp1_chain_enum =
370 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX6_B1_CTL, 0, 12, rx_mix1_text);
371
372static const struct soc_enum rx6_mix1_inp2_chain_enum =
373 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX6_B1_CTL, 4, 12, rx_mix1_text);
374
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700375static const struct soc_enum rx7_mix1_inp1_chain_enum =
376 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX7_B1_CTL, 0, 12, rx_mix1_text);
377
378static const struct soc_enum rx7_mix1_inp2_chain_enum =
379 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX7_B1_CTL, 4, 12, rx_mix1_text);
380
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700381static const struct soc_enum sb_tx5_mux_enum =
382 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B5_CTL, 0, 9, sb_tx5_mux_text);
383
384static const struct soc_enum sb_tx6_mux_enum =
385 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B6_CTL, 0, 9, sb_tx6_mux_text);
386
387static const struct soc_enum sb_tx7_mux_enum =
388 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B7_CTL, 0, 18,
389 sb_tx7_to_tx10_mux_text);
390
391static const struct soc_enum sb_tx8_mux_enum =
392 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B8_CTL, 0, 18,
393 sb_tx7_to_tx10_mux_text);
394
395static const struct soc_enum sb_tx1_mux_enum =
396 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B1_CTL, 0, 9, sb_tx1_mux_text);
397
398static const struct soc_enum dec1_mux_enum =
399 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 0, 3, dec1_mux_text);
400
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700401static const struct soc_enum dec2_mux_enum =
402 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 2, 3, dec2_mux_text);
403
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700404static const struct soc_enum dec3_mux_enum =
405 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 4, 3, dec3_mux_text);
406
407static const struct soc_enum dec4_mux_enum =
408 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 6, 3, dec4_mux_text);
409
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700410static const struct soc_enum dec5_mux_enum =
411 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B2_CTL, 0, 3, dec5_mux_text);
412
413static const struct soc_enum dec6_mux_enum =
414 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B2_CTL, 2, 3, dec6_mux_text);
415
416static const struct soc_enum dec7_mux_enum =
417 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B2_CTL, 4, 7, dec7_mux_text);
418
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700419static const struct soc_enum dec8_mux_enum =
420 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B3_CTL, 0, 7, dec8_mux_text);
421
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700422static const struct soc_enum dec9_mux_enum =
423 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B3_CTL, 3, 8, dec9_mux_text);
424
425static const struct soc_enum dec10_mux_enum =
426 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B4_CTL, 0, 8, dec10_mux_text);
427
Bradley Rubin229c6a52011-07-12 16:18:48 -0700428static const struct soc_enum anc1_mux_enum =
429 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_ANC_B1_CTL, 0, 16, anc_mux_text);
430
431static const struct soc_enum anc2_mux_enum =
432 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_ANC_B1_CTL, 4, 16, anc_mux_text);
433
434static const struct soc_enum anc1_fb_mux_enum =
435 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_ANC_B2_CTL, 0, 3, anc1_fb_mux_text);
436
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700437static const struct soc_enum iir1_inp1_mux_enum =
438 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_EQ1_B1_CTL, 0, 18, iir1_inp1_text);
439
440static const struct snd_kcontrol_new rx_mix1_inp1_mux =
441 SOC_DAPM_ENUM("RX1 MIX1 INP1 Mux", rx_mix1_inp1_chain_enum);
442
Bradley Rubin229c6a52011-07-12 16:18:48 -0700443static const struct snd_kcontrol_new rx_mix1_inp2_mux =
444 SOC_DAPM_ENUM("RX1 MIX1 INP2 Mux", rx_mix1_inp2_chain_enum);
445
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700446static const struct snd_kcontrol_new rx2_mix1_inp1_mux =
447 SOC_DAPM_ENUM("RX2 MIX1 INP1 Mux", rx2_mix1_inp1_chain_enum);
448
Bradley Rubin229c6a52011-07-12 16:18:48 -0700449static const struct snd_kcontrol_new rx2_mix1_inp2_mux =
450 SOC_DAPM_ENUM("RX2 MIX1 INP2 Mux", rx2_mix1_inp2_chain_enum);
451
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700452static const struct snd_kcontrol_new rx3_mix1_inp1_mux =
453 SOC_DAPM_ENUM("RX3 MIX1 INP1 Mux", rx3_mix1_inp1_chain_enum);
454
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700455static const struct snd_kcontrol_new rx3_mix1_inp2_mux =
456 SOC_DAPM_ENUM("RX3 MIX1 INP2 Mux", rx3_mix1_inp2_chain_enum);
457
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700458static const struct snd_kcontrol_new rx4_mix1_inp1_mux =
459 SOC_DAPM_ENUM("RX4 MIX1 INP1 Mux", rx4_mix1_inp1_chain_enum);
460
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700461static const struct snd_kcontrol_new rx4_mix1_inp2_mux =
462 SOC_DAPM_ENUM("RX4 MIX1 INP2 Mux", rx4_mix1_inp2_chain_enum);
463
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700464static const struct snd_kcontrol_new rx5_mix1_inp1_mux =
465 SOC_DAPM_ENUM("RX5 MIX1 INP1 Mux", rx5_mix1_inp1_chain_enum);
466
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700467static const struct snd_kcontrol_new rx5_mix1_inp2_mux =
468 SOC_DAPM_ENUM("RX5 MIX1 INP2 Mux", rx5_mix1_inp2_chain_enum);
469
470static const struct snd_kcontrol_new rx6_mix1_inp1_mux =
471 SOC_DAPM_ENUM("RX6 MIX1 INP1 Mux", rx6_mix1_inp1_chain_enum);
472
473static const struct snd_kcontrol_new rx6_mix1_inp2_mux =
474 SOC_DAPM_ENUM("RX6 MIX1 INP2 Mux", rx6_mix1_inp2_chain_enum);
475
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700476static const struct snd_kcontrol_new rx7_mix1_inp1_mux =
477 SOC_DAPM_ENUM("RX7 MIX1 INP1 Mux", rx7_mix1_inp1_chain_enum);
478
479static const struct snd_kcontrol_new rx7_mix1_inp2_mux =
480 SOC_DAPM_ENUM("RX7 MIX1 INP2 Mux", rx7_mix1_inp2_chain_enum);
481
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700482static const struct snd_kcontrol_new sb_tx5_mux =
483 SOC_DAPM_ENUM("SLIM TX5 MUX Mux", sb_tx5_mux_enum);
484
485static const struct snd_kcontrol_new sb_tx6_mux =
486 SOC_DAPM_ENUM("SLIM TX6 MUX Mux", sb_tx6_mux_enum);
487
488static const struct snd_kcontrol_new sb_tx7_mux =
489 SOC_DAPM_ENUM("SLIM TX7 MUX Mux", sb_tx7_mux_enum);
490
491static const struct snd_kcontrol_new sb_tx8_mux =
492 SOC_DAPM_ENUM("SLIM TX8 MUX Mux", sb_tx8_mux_enum);
493
494static const struct snd_kcontrol_new sb_tx1_mux =
495 SOC_DAPM_ENUM("SLIM TX1 MUX Mux", sb_tx1_mux_enum);
496
497static const struct snd_kcontrol_new dec1_mux =
498 SOC_DAPM_ENUM("DEC1 MUX Mux", dec1_mux_enum);
499
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700500static const struct snd_kcontrol_new dec2_mux =
501 SOC_DAPM_ENUM("DEC2 MUX Mux", dec2_mux_enum);
502
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700503static const struct snd_kcontrol_new dec3_mux =
504 SOC_DAPM_ENUM("DEC3 MUX Mux", dec3_mux_enum);
505
506static const struct snd_kcontrol_new dec4_mux =
507 SOC_DAPM_ENUM("DEC4 MUX Mux", dec4_mux_enum);
508
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700509static const struct snd_kcontrol_new dec5_mux =
510 SOC_DAPM_ENUM("DEC5 MUX Mux", dec5_mux_enum);
511
512static const struct snd_kcontrol_new dec6_mux =
513 SOC_DAPM_ENUM("DEC6 MUX Mux", dec6_mux_enum);
514
515static const struct snd_kcontrol_new dec7_mux =
516 SOC_DAPM_ENUM("DEC7 MUX Mux", dec7_mux_enum);
517
Bradley Rubin229c6a52011-07-12 16:18:48 -0700518static const struct snd_kcontrol_new anc1_mux =
519 SOC_DAPM_ENUM("ANC1 MUX Mux", anc1_mux_enum);
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700520static const struct snd_kcontrol_new dec8_mux =
521 SOC_DAPM_ENUM("DEC8 MUX Mux", dec8_mux_enum);
522
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700523static const struct snd_kcontrol_new dec9_mux =
524 SOC_DAPM_ENUM("DEC9 MUX Mux", dec9_mux_enum);
525
526static const struct snd_kcontrol_new dec10_mux =
527 SOC_DAPM_ENUM("DEC10 MUX Mux", dec10_mux_enum);
528
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700529static const struct snd_kcontrol_new iir1_inp1_mux =
530 SOC_DAPM_ENUM("IIR1 INP1 Mux", iir1_inp1_mux_enum);
531
Bradley Rubin229c6a52011-07-12 16:18:48 -0700532static const struct snd_kcontrol_new anc2_mux =
533 SOC_DAPM_ENUM("ANC2 MUX Mux", anc2_mux_enum);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700534
Bradley Rubin229c6a52011-07-12 16:18:48 -0700535static const struct snd_kcontrol_new anc1_fb_mux =
536 SOC_DAPM_ENUM("ANC1 FB MUX Mux", anc1_fb_mux_enum);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700537
Bradley Rubin229c6a52011-07-12 16:18:48 -0700538static const struct snd_kcontrol_new dac1_switch[] = {
539 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_EAR_EN, 5, 1, 0)
540};
541static const struct snd_kcontrol_new hphl_switch[] = {
542 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_HPH_L_DAC_CTL, 6, 1, 0)
543};
544static const struct snd_kcontrol_new hphr_switch[] = {
545 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_HPH_R_DAC_CTL, 6, 1, 0)
546};
547static const struct snd_kcontrol_new lineout1_switch[] = {
548 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_1_DAC_CTL, 6, 1, 0)
549};
550static const struct snd_kcontrol_new lineout2_switch[] = {
551 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_2_DAC_CTL, 6, 1, 0)
552};
553static const struct snd_kcontrol_new lineout3_switch[] = {
554 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_3_DAC_CTL, 6, 1, 0)
555};
556static const struct snd_kcontrol_new lineout4_switch[] = {
557 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_4_DAC_CTL, 6, 1, 0)
558};
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700559static const struct snd_kcontrol_new lineout5_switch[] = {
560 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_5_DAC_CTL, 6, 1, 0)
561};
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700562
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700563static void tabla_codec_enable_adc_block(struct snd_soc_codec *codec,
564 int enable)
565{
566 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
567
568 pr_debug("%s %d\n", __func__, enable);
569
570 if (enable) {
571 tabla->adc_count++;
572 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS, 0xE0, 0xE0);
573 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL, 0x2, 0x2);
574 } else {
575 tabla->adc_count--;
576 if (!tabla->adc_count) {
577 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL,
578 0x2, 0x0);
579 if (!tabla->mbhc_polling_active)
580 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS,
581 0xE0, 0x0);
582 }
583 }
584}
585
586static int tabla_codec_enable_adc(struct snd_soc_dapm_widget *w,
587 struct snd_kcontrol *kcontrol, int event)
588{
589 struct snd_soc_codec *codec = w->codec;
590 u16 adc_reg;
591
592 pr_debug("%s %d\n", __func__, event);
593
594 if (w->reg == TABLA_A_TX_1_2_EN)
595 adc_reg = TABLA_A_TX_1_2_TEST_CTL;
596 else if (w->reg == TABLA_A_TX_3_4_EN)
597 adc_reg = TABLA_A_TX_3_4_TEST_CTL;
598 else if (w->reg == TABLA_A_TX_5_6_EN)
599 adc_reg = TABLA_A_TX_5_6_TEST_CTL;
600 else {
601 pr_err("%s: Error, invalid adc register\n", __func__);
602 return -EINVAL;
603 }
604
605 switch (event) {
606 case SND_SOC_DAPM_PRE_PMU:
607 tabla_codec_enable_adc_block(codec, 1);
608 break;
609 case SND_SOC_DAPM_POST_PMU:
610 snd_soc_update_bits(codec, adc_reg, 1 << w->shift,
611 1 << w->shift);
612 usleep_range(1000, 1000);
613 snd_soc_update_bits(codec, adc_reg, 1 << w->shift, 0x00);
614 usleep_range(1000, 1000);
615 break;
616 case SND_SOC_DAPM_POST_PMD:
617 tabla_codec_enable_adc_block(codec, 0);
618 break;
619 }
620 return 0;
621}
622
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700623static int tabla_codec_enable_lineout(struct snd_soc_dapm_widget *w,
624 struct snd_kcontrol *kcontrol, int event)
625{
626 struct snd_soc_codec *codec = w->codec;
627 u16 lineout_gain_reg;
628
Kiran Kandidb0a4b02011-08-23 09:32:09 -0700629 pr_debug("%s %d %s\n", __func__, event, w->name);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700630
631 switch (w->shift) {
632 case 0:
633 lineout_gain_reg = TABLA_A_RX_LINE_1_GAIN;
634 break;
635 case 1:
636 lineout_gain_reg = TABLA_A_RX_LINE_2_GAIN;
637 break;
638 case 2:
639 lineout_gain_reg = TABLA_A_RX_LINE_3_GAIN;
640 break;
641 case 3:
642 lineout_gain_reg = TABLA_A_RX_LINE_4_GAIN;
643 break;
644 case 4:
645 lineout_gain_reg = TABLA_A_RX_LINE_5_GAIN;
646 break;
647 default:
648 pr_err("%s: Error, incorrect lineout register value\n",
649 __func__);
650 return -EINVAL;
651 }
652
653 switch (event) {
654 case SND_SOC_DAPM_PRE_PMU:
655 snd_soc_update_bits(codec, lineout_gain_reg, 0x40, 0x40);
656 break;
657 case SND_SOC_DAPM_POST_PMU:
Kiran Kandidb0a4b02011-08-23 09:32:09 -0700658 pr_debug("%s: sleeping 40 ms after %s PA turn on\n",
659 __func__, w->name);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700660 usleep_range(40000, 40000);
661 break;
662 case SND_SOC_DAPM_POST_PMD:
663 snd_soc_update_bits(codec, lineout_gain_reg, 0x40, 0x00);
664 break;
665 }
666 return 0;
667}
668
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700669
670static int tabla_codec_enable_dmic(struct snd_soc_dapm_widget *w,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700671 struct snd_kcontrol *kcontrol, int event)
672{
673 struct snd_soc_codec *codec = w->codec;
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700674 u16 tx_mux_ctl_reg, tx_dmic_ctl_reg;
675 u8 dmic_clk_sel, dmic_clk_en;
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -0700676 unsigned int dmic;
677 int ret;
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700678
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -0700679 ret = kstrtouint(strpbrk(w->name, "123456"), 10, &dmic);
680 if (ret < 0) {
681 pr_err("%s: Invalid DMIC line on the codec\n", __func__);
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700682 return -EINVAL;
683 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700684
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -0700685 switch (dmic) {
686 case 1:
687 case 2:
688 dmic_clk_sel = 0x02;
689 dmic_clk_en = 0x01;
690 break;
691
692 case 3:
693 case 4:
694 dmic_clk_sel = 0x08;
695 dmic_clk_en = 0x04;
696 break;
697
698 case 5:
699 case 6:
700 dmic_clk_sel = 0x20;
701 dmic_clk_en = 0x10;
702 break;
703
704 default:
705 pr_err("%s: Invalid DMIC Selection\n", __func__);
706 return -EINVAL;
707 }
708
709 tx_mux_ctl_reg = TABLA_A_CDC_TX1_MUX_CTL + 8 * (dmic - 1);
710 tx_dmic_ctl_reg = TABLA_A_CDC_TX1_DMIC_CTL + 8 * (dmic - 1);
711
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700712 pr_debug("%s %d\n", __func__, event);
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700713
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700714 switch (event) {
715 case SND_SOC_DAPM_PRE_PMU:
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700716 snd_soc_update_bits(codec, tx_mux_ctl_reg, 0x1, 0x1);
717
718 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_DMIC_CTL,
719 dmic_clk_sel, dmic_clk_sel);
720
721 snd_soc_update_bits(codec, tx_dmic_ctl_reg, 0x1, 0x1);
722
723 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_DMIC_CTL,
724 dmic_clk_en, dmic_clk_en);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700725 break;
726 case SND_SOC_DAPM_POST_PMD:
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700727 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_DMIC_CTL,
728 dmic_clk_en, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700729 break;
730 }
731 return 0;
732}
733
Bradley Rubin229c6a52011-07-12 16:18:48 -0700734static int tabla_codec_enable_anc(struct snd_soc_dapm_widget *w,
735 struct snd_kcontrol *kcontrol, int event)
736{
737 struct snd_soc_codec *codec = w->codec;
738 const char *filename;
739 const struct firmware *fw;
740 int i;
741 int ret;
Bradley Rubina7096d02011-08-03 18:29:02 -0700742 int num_anc_slots;
743 struct anc_header *anc_head;
Bradley Rubin229c6a52011-07-12 16:18:48 -0700744 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
Bradley Rubina7096d02011-08-03 18:29:02 -0700745 u32 anc_writes_size = 0;
746 int anc_size_remaining;
747 u32 *anc_ptr;
Bradley Rubin229c6a52011-07-12 16:18:48 -0700748 u16 reg;
749 u8 mask, val, old_val;
750
751 pr_debug("%s %d\n", __func__, event);
752 switch (event) {
753 case SND_SOC_DAPM_PRE_PMU:
754
Bradley Rubin4283a4c2011-07-29 16:18:54 -0700755 filename = "wcd9310/wcd9310_anc.bin";
Bradley Rubin229c6a52011-07-12 16:18:48 -0700756
757 ret = request_firmware(&fw, filename, codec->dev);
758 if (ret != 0) {
759 dev_err(codec->dev, "Failed to acquire ANC data: %d\n",
760 ret);
761 return -ENODEV;
762 }
763
Bradley Rubina7096d02011-08-03 18:29:02 -0700764 if (fw->size < sizeof(struct anc_header)) {
Bradley Rubin229c6a52011-07-12 16:18:48 -0700765 dev_err(codec->dev, "Not enough data\n");
766 release_firmware(fw);
767 return -ENOMEM;
768 }
769
770 /* First number is the number of register writes */
Bradley Rubina7096d02011-08-03 18:29:02 -0700771 anc_head = (struct anc_header *)(fw->data);
772 anc_ptr = (u32 *)((u32)fw->data + sizeof(struct anc_header));
773 anc_size_remaining = fw->size - sizeof(struct anc_header);
774 num_anc_slots = anc_head->num_anc_slots;
Bradley Rubin229c6a52011-07-12 16:18:48 -0700775
Bradley Rubina7096d02011-08-03 18:29:02 -0700776 if (tabla->anc_slot >= num_anc_slots) {
777 dev_err(codec->dev, "Invalid ANC slot selected\n");
778 release_firmware(fw);
779 return -EINVAL;
780 }
781
782 for (i = 0; i < num_anc_slots; i++) {
783
784 if (anc_size_remaining < TABLA_PACKED_REG_SIZE) {
785 dev_err(codec->dev, "Invalid register format\n");
786 release_firmware(fw);
787 return -EINVAL;
788 }
789 anc_writes_size = (u32)(*anc_ptr);
790 anc_size_remaining -= sizeof(u32);
791 anc_ptr += 1;
792
793 if (anc_writes_size * TABLA_PACKED_REG_SIZE
794 > anc_size_remaining) {
795 dev_err(codec->dev, "Invalid register format\n");
796 release_firmware(fw);
797 return -ENOMEM;
798 }
799
800 if (tabla->anc_slot == i)
801 break;
802
803 anc_size_remaining -= (anc_writes_size *
804 TABLA_PACKED_REG_SIZE);
Bradley Rubin939ff3f2011-08-26 17:19:34 -0700805 anc_ptr += anc_writes_size;
Bradley Rubina7096d02011-08-03 18:29:02 -0700806 }
807 if (i == num_anc_slots) {
808 dev_err(codec->dev, "Selected ANC slot not present\n");
Bradley Rubin229c6a52011-07-12 16:18:48 -0700809 release_firmware(fw);
810 return -ENOMEM;
811 }
812
Bradley Rubina7096d02011-08-03 18:29:02 -0700813 for (i = 0; i < anc_writes_size; i++) {
814 TABLA_CODEC_UNPACK_ENTRY(anc_ptr[i], reg,
Bradley Rubin229c6a52011-07-12 16:18:48 -0700815 mask, val);
816 old_val = snd_soc_read(codec, reg);
Bradley Rubin4283a4c2011-07-29 16:18:54 -0700817 snd_soc_write(codec, reg, (old_val & ~mask) |
818 (val & mask));
Bradley Rubin229c6a52011-07-12 16:18:48 -0700819 }
820 release_firmware(fw);
Bradley Rubin229c6a52011-07-12 16:18:48 -0700821
822 break;
823 case SND_SOC_DAPM_POST_PMD:
824 snd_soc_write(codec, TABLA_A_CDC_CLK_ANC_RESET_CTL, 0xFF);
825 snd_soc_write(codec, TABLA_A_CDC_CLK_ANC_CLK_EN_CTL, 0);
826 break;
827 }
828 return 0;
829}
830
Patrick Lai3043fba2011-08-01 14:15:57 -0700831static void tabla_codec_update_cfilt_usage(struct snd_soc_codec *codec,
832 u8 cfilt_sel, int inc)
833{
834 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
835 u32 *cfilt_cnt_ptr = NULL;
836 u16 micb_cfilt_reg;
837
838 switch (cfilt_sel) {
839 case TABLA_CFILT1_SEL:
840 cfilt_cnt_ptr = &tabla->cfilt1_cnt;
841 micb_cfilt_reg = TABLA_A_MICB_CFILT_1_CTL;
842 break;
843 case TABLA_CFILT2_SEL:
844 cfilt_cnt_ptr = &tabla->cfilt2_cnt;
845 micb_cfilt_reg = TABLA_A_MICB_CFILT_2_CTL;
846 break;
847 case TABLA_CFILT3_SEL:
848 cfilt_cnt_ptr = &tabla->cfilt3_cnt;
849 micb_cfilt_reg = TABLA_A_MICB_CFILT_3_CTL;
850 break;
851 default:
852 return; /* should not happen */
853 }
854
855 if (inc) {
856 if (!(*cfilt_cnt_ptr)++)
857 snd_soc_update_bits(codec, micb_cfilt_reg, 0x80, 0x80);
858 } else {
859 /* check if count not zero, decrement
860 * then check if zero, go ahead disable cfilter
861 */
862 if ((*cfilt_cnt_ptr) && !--(*cfilt_cnt_ptr))
863 snd_soc_update_bits(codec, micb_cfilt_reg, 0x80, 0);
864 }
865}
Bradley Rubin229c6a52011-07-12 16:18:48 -0700866
Bradley Rubincb3950a2011-08-18 13:07:26 -0700867static void tabla_codec_disable_button_presses(struct snd_soc_codec *codec)
868{
869 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B4_CTL, 0x80);
870 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B3_CTL, 0x00);
871}
872
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700873static void tabla_codec_start_hs_polling(struct snd_soc_codec *codec)
874{
Bradley Rubincb3950a2011-08-18 13:07:26 -0700875 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
876
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700877 snd_soc_write(codec, TABLA_A_MBHC_SCALING_MUX_1, 0x84);
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700878 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
Bradley Rubincb3950a2011-08-18 13:07:26 -0700879 if (!tabla->no_mic_headset_override) {
880 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
881 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
882 } else {
883 tabla_codec_disable_button_presses(codec);
884 }
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700885 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x1);
886 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x0);
887 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x1);
888}
889
890static void tabla_codec_pause_hs_polling(struct snd_soc_codec *codec)
891{
Bradley Rubincb3950a2011-08-18 13:07:26 -0700892 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
893
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700894 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
895 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
Bradley Rubincb3950a2011-08-18 13:07:26 -0700896 if (!tabla->no_mic_headset_override) {
897 tabla_disable_irq(codec->control_data,
898 TABLA_IRQ_MBHC_POTENTIAL);
899 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
900 }
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700901}
902
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700903static int tabla_codec_enable_micbias(struct snd_soc_dapm_widget *w,
904 struct snd_kcontrol *kcontrol, int event)
905{
906 struct snd_soc_codec *codec = w->codec;
Patrick Lai3043fba2011-08-01 14:15:57 -0700907 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
908 u16 micb_int_reg;
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700909 int micb_line;
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700910 u8 cfilt_sel_val = 0;
Bradley Rubin229c6a52011-07-12 16:18:48 -0700911 char *internal1_text = "Internal1";
912 char *internal2_text = "Internal2";
913 char *internal3_text = "Internal3";
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700914
915 pr_debug("%s %d\n", __func__, event);
916 switch (w->reg) {
917 case TABLA_A_MICB_1_CTL:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700918 micb_int_reg = TABLA_A_MICB_1_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -0700919 cfilt_sel_val = tabla->pdata->micbias.bias1_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700920 micb_line = TABLA_MICBIAS1;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700921 break;
922 case TABLA_A_MICB_2_CTL:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700923 micb_int_reg = TABLA_A_MICB_2_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -0700924 cfilt_sel_val = tabla->pdata->micbias.bias2_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700925 micb_line = TABLA_MICBIAS2;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700926 break;
927 case TABLA_A_MICB_3_CTL:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700928 micb_int_reg = TABLA_A_MICB_3_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -0700929 cfilt_sel_val = tabla->pdata->micbias.bias3_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700930 micb_line = TABLA_MICBIAS3;
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700931 break;
932 case TABLA_A_MICB_4_CTL:
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700933 micb_int_reg = TABLA_A_MICB_4_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -0700934 cfilt_sel_val = tabla->pdata->micbias.bias4_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700935 micb_line = TABLA_MICBIAS4;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700936 break;
937 default:
938 pr_err("%s: Error, invalid micbias register\n", __func__);
939 return -EINVAL;
940 }
941
942 switch (event) {
943 case SND_SOC_DAPM_PRE_PMU:
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700944 snd_soc_update_bits(codec, w->reg, 0x0E, 0x0A);
Patrick Lai3043fba2011-08-01 14:15:57 -0700945 tabla_codec_update_cfilt_usage(codec, cfilt_sel_val, 1);
Bradley Rubin229c6a52011-07-12 16:18:48 -0700946
947 if (strnstr(w->name, internal1_text, 30))
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700948 snd_soc_update_bits(codec, micb_int_reg, 0xE0, 0xE0);
Bradley Rubin229c6a52011-07-12 16:18:48 -0700949 else if (strnstr(w->name, internal2_text, 30))
950 snd_soc_update_bits(codec, micb_int_reg, 0x1C, 0x1C);
951 else if (strnstr(w->name, internal3_text, 30))
952 snd_soc_update_bits(codec, micb_int_reg, 0x3, 0x3);
953
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700954 break;
Bradley Rubin4d09cf42011-08-17 17:59:16 -0700955 case SND_SOC_DAPM_POST_PMU:
956 if (tabla->mbhc_polling_active &&
957 (tabla->calibration->bias == micb_line)) {
958 tabla_codec_pause_hs_polling(codec);
959 tabla_codec_start_hs_polling(codec);
960 }
961 break;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700962 case SND_SOC_DAPM_POST_PMD:
Bradley Rubin229c6a52011-07-12 16:18:48 -0700963 if (strnstr(w->name, internal1_text, 30))
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700964 snd_soc_update_bits(codec, micb_int_reg, 0x80, 0x00);
Bradley Rubin229c6a52011-07-12 16:18:48 -0700965 else if (strnstr(w->name, internal2_text, 30))
966 snd_soc_update_bits(codec, micb_int_reg, 0x10, 0x00);
967 else if (strnstr(w->name, internal3_text, 30))
968 snd_soc_update_bits(codec, micb_int_reg, 0x2, 0x0);
969
Patrick Lai3043fba2011-08-01 14:15:57 -0700970 tabla_codec_update_cfilt_usage(codec, cfilt_sel_val, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700971 break;
972 }
973
974 return 0;
975}
976
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700977static int tabla_codec_enable_dec(struct snd_soc_dapm_widget *w,
978 struct snd_kcontrol *kcontrol, int event)
979{
980 struct snd_soc_codec *codec = w->codec;
981 u16 dec_reset_reg;
982
983 pr_debug("%s %d\n", __func__, event);
984
985 if (w->reg == TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL)
986 dec_reset_reg = TABLA_A_CDC_CLK_TX_RESET_B1_CTL;
987 else if (w->reg == TABLA_A_CDC_CLK_TX_CLK_EN_B2_CTL)
988 dec_reset_reg = TABLA_A_CDC_CLK_TX_RESET_B2_CTL;
989 else {
990 pr_err("%s: Error, incorrect dec\n", __func__);
991 return -EINVAL;
992 }
993
994 switch (event) {
995 case SND_SOC_DAPM_PRE_PMU:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700996 snd_soc_update_bits(codec, dec_reset_reg, 1 << w->shift,
997 1 << w->shift);
998 snd_soc_update_bits(codec, dec_reset_reg, 1 << w->shift, 0x0);
999 break;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001000 }
1001 return 0;
1002}
1003
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001004static int tabla_codec_reset_interpolator(struct snd_soc_dapm_widget *w,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001005 struct snd_kcontrol *kcontrol, int event)
1006{
1007 struct snd_soc_codec *codec = w->codec;
1008
1009 switch (event) {
1010 case SND_SOC_DAPM_PRE_PMU:
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001011 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_RX_RESET_CTL,
1012 1 << w->shift, 1 << w->shift);
1013 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_RX_RESET_CTL,
1014 1 << w->shift, 0x0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001015 break;
1016 }
1017 return 0;
1018}
1019
Bradley Rubin229c6a52011-07-12 16:18:48 -07001020static int tabla_codec_enable_ldo_h(struct snd_soc_dapm_widget *w,
1021 struct snd_kcontrol *kcontrol, int event)
1022{
1023 switch (event) {
1024 case SND_SOC_DAPM_POST_PMU:
1025 case SND_SOC_DAPM_POST_PMD:
1026 usleep_range(1000, 1000);
1027 break;
1028 }
1029 return 0;
1030}
1031
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001032
1033static void tabla_enable_rx_bias(struct snd_soc_codec *codec, u32 enable)
1034{
1035 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1036
1037 if (enable) {
1038 tabla->rx_bias_count++;
1039 if (tabla->rx_bias_count == 1)
1040 snd_soc_update_bits(codec, TABLA_A_RX_COM_BIAS,
1041 0x80, 0x80);
1042 } else {
1043 tabla->rx_bias_count--;
1044 if (!tabla->rx_bias_count)
1045 snd_soc_update_bits(codec, TABLA_A_RX_COM_BIAS,
1046 0x80, 0x00);
1047 }
1048}
1049
1050static int tabla_codec_enable_rx_bias(struct snd_soc_dapm_widget *w,
1051 struct snd_kcontrol *kcontrol, int event)
1052{
1053 struct snd_soc_codec *codec = w->codec;
1054
1055 pr_debug("%s %d\n", __func__, event);
1056
1057 switch (event) {
1058 case SND_SOC_DAPM_PRE_PMU:
1059 tabla_enable_rx_bias(codec, 1);
1060 break;
1061 case SND_SOC_DAPM_POST_PMD:
1062 tabla_enable_rx_bias(codec, 0);
1063 break;
1064 }
1065 return 0;
1066}
1067
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001068
1069static int tabla_hph_pa_event(struct snd_soc_dapm_widget *w,
1070 struct snd_kcontrol *kcontrol, int event)
1071{
1072
1073 pr_debug("%s: event = %d\n", __func__, event);
1074
1075 switch (event) {
1076 case SND_SOC_DAPM_POST_PMD:
1077
1078 pr_debug("%s: sleep 10 ms after %s PA disable.\n", __func__,
1079 w->name);
1080 usleep_range(10000, 10000);
1081
1082 break;
1083 }
1084 return 0;
1085}
1086
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001087static const struct snd_soc_dapm_widget tabla_dapm_widgets[] = {
1088 /*RX stuff */
1089 SND_SOC_DAPM_OUTPUT("EAR"),
1090
Kiran Kandid2d86b52011-09-09 17:44:28 -07001091 SND_SOC_DAPM_PGA("EAR PA", TABLA_A_RX_EAR_EN, 4, 0, NULL, 0),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001092
Bradley Rubin229c6a52011-07-12 16:18:48 -07001093 SND_SOC_DAPM_MIXER("DAC1", TABLA_A_RX_EAR_EN, 6, 0, dac1_switch,
1094 ARRAY_SIZE(dac1_switch)),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001095
Bradley Rubin229c6a52011-07-12 16:18:48 -07001096 SND_SOC_DAPM_AIF_IN("SLIM RX1", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1097 SND_SOC_DAPM_AIF_IN("SLIM RX2", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001098
1099 /* Headphone */
1100 SND_SOC_DAPM_OUTPUT("HEADPHONE"),
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001101 SND_SOC_DAPM_PGA_E("HPHL", TABLA_A_RX_HPH_CNP_EN, 5, 0, NULL, 0,
1102 tabla_hph_pa_event, SND_SOC_DAPM_POST_PMD),
1103
Bradley Rubin229c6a52011-07-12 16:18:48 -07001104 SND_SOC_DAPM_MIXER("HPHL DAC", TABLA_A_RX_HPH_L_DAC_CTL, 7, 0,
1105 hphl_switch, ARRAY_SIZE(hphl_switch)),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001106
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001107 SND_SOC_DAPM_PGA_E("HPHR", TABLA_A_RX_HPH_CNP_EN, 4, 0, NULL, 0,
1108 tabla_hph_pa_event, SND_SOC_DAPM_POST_PMD),
1109
Bradley Rubin229c6a52011-07-12 16:18:48 -07001110 SND_SOC_DAPM_MIXER("HPHR DAC", TABLA_A_RX_HPH_R_DAC_CTL, 7, 0,
1111 hphr_switch, ARRAY_SIZE(hphr_switch)),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001112
1113 /* Speaker */
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001114 SND_SOC_DAPM_OUTPUT("LINEOUT1"),
1115 SND_SOC_DAPM_OUTPUT("LINEOUT2"),
1116 SND_SOC_DAPM_OUTPUT("LINEOUT3"),
1117 SND_SOC_DAPM_OUTPUT("LINEOUT4"),
1118 SND_SOC_DAPM_OUTPUT("LINEOUT5"),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001119
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001120 SND_SOC_DAPM_PGA_E("LINEOUT1 PA", TABLA_A_RX_LINE_CNP_EN, 0, 0, NULL,
1121 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1122 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1123 SND_SOC_DAPM_PGA_E("LINEOUT2 PA", TABLA_A_RX_LINE_CNP_EN, 1, 0, NULL,
1124 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1125 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1126 SND_SOC_DAPM_PGA_E("LINEOUT3 PA", TABLA_A_RX_LINE_CNP_EN, 2, 0, NULL,
1127 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1128 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1129 SND_SOC_DAPM_PGA_E("LINEOUT4 PA", TABLA_A_RX_LINE_CNP_EN, 3, 0, NULL,
1130 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1131 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1132 SND_SOC_DAPM_PGA_E("LINEOUT5 PA", TABLA_A_RX_LINE_CNP_EN, 4, 0, NULL, 0,
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001133 tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1134 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001135
Bradley Rubin229c6a52011-07-12 16:18:48 -07001136 SND_SOC_DAPM_MIXER("LINEOUT1 DAC", TABLA_A_RX_LINE_1_DAC_CTL, 7, 0,
1137 lineout1_switch, ARRAY_SIZE(lineout1_switch)),
1138 SND_SOC_DAPM_MIXER("LINEOUT2 DAC", TABLA_A_RX_LINE_2_DAC_CTL, 7, 0,
1139 lineout2_switch, ARRAY_SIZE(lineout2_switch)),
1140 SND_SOC_DAPM_MIXER("LINEOUT3 DAC", TABLA_A_RX_LINE_3_DAC_CTL, 7, 0,
1141 lineout3_switch, ARRAY_SIZE(lineout3_switch)),
1142 SND_SOC_DAPM_MIXER("LINEOUT4 DAC", TABLA_A_RX_LINE_4_DAC_CTL, 7, 0,
1143 lineout4_switch, ARRAY_SIZE(lineout4_switch)),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001144 SND_SOC_DAPM_MIXER("LINEOUT5 DAC", TABLA_A_RX_LINE_5_DAC_CTL, 7, 0,
1145 lineout5_switch, ARRAY_SIZE(lineout5_switch)),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001146
Bradley Rubin229c6a52011-07-12 16:18:48 -07001147 SND_SOC_DAPM_MIXER_E("RX1 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 0, 0, NULL,
1148 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1149 SND_SOC_DAPM_MIXER_E("RX2 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 1, 0, NULL,
1150 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1151 SND_SOC_DAPM_MIXER_E("RX3 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 2, 0, NULL,
1152 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1153 SND_SOC_DAPM_MIXER_E("RX4 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 3, 0, NULL,
1154 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1155 SND_SOC_DAPM_MIXER_E("RX5 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 4, 0, NULL,
1156 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1157 SND_SOC_DAPM_MIXER_E("RX6 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 5, 0, NULL,
1158 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001159 SND_SOC_DAPM_MIXER_E("RX7 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 6, 0, NULL,
1160 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001161
Bradley Rubin229c6a52011-07-12 16:18:48 -07001162 SND_SOC_DAPM_MIXER("RX1 CHAIN", TABLA_A_CDC_RX1_B6_CTL, 5, 0, NULL, 0),
1163 SND_SOC_DAPM_MIXER("RX2 CHAIN", TABLA_A_CDC_RX2_B6_CTL, 5, 0, NULL, 0),
1164
1165 SND_SOC_DAPM_MUX("RX1 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1166 &rx_mix1_inp1_mux),
1167 SND_SOC_DAPM_MUX("RX1 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1168 &rx_mix1_inp2_mux),
1169 SND_SOC_DAPM_MUX("RX2 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1170 &rx2_mix1_inp1_mux),
1171 SND_SOC_DAPM_MUX("RX2 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1172 &rx2_mix1_inp2_mux),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001173 SND_SOC_DAPM_MUX("RX3 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1174 &rx3_mix1_inp1_mux),
1175 SND_SOC_DAPM_MUX("RX3 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1176 &rx3_mix1_inp2_mux),
1177 SND_SOC_DAPM_MUX("RX4 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1178 &rx4_mix1_inp1_mux),
1179 SND_SOC_DAPM_MUX("RX4 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1180 &rx4_mix1_inp2_mux),
1181 SND_SOC_DAPM_MUX("RX5 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1182 &rx5_mix1_inp1_mux),
1183 SND_SOC_DAPM_MUX("RX5 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1184 &rx5_mix1_inp2_mux),
1185 SND_SOC_DAPM_MUX("RX6 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1186 &rx6_mix1_inp1_mux),
1187 SND_SOC_DAPM_MUX("RX6 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1188 &rx6_mix1_inp2_mux),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001189 SND_SOC_DAPM_MUX("RX7 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1190 &rx7_mix1_inp1_mux),
1191 SND_SOC_DAPM_MUX("RX7 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1192 &rx7_mix1_inp2_mux),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001193
Bradley Rubin229c6a52011-07-12 16:18:48 -07001194 SND_SOC_DAPM_SUPPLY("CP", TABLA_A_CP_EN, 0, 0,
1195 tabla_codec_enable_charge_pump, SND_SOC_DAPM_POST_PMU |
1196 SND_SOC_DAPM_PRE_PMD),
1197
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001198 SND_SOC_DAPM_SUPPLY("RX_BIAS", SND_SOC_NOPM, 0, 0,
1199 tabla_codec_enable_rx_bias, SND_SOC_DAPM_PRE_PMU |
1200 SND_SOC_DAPM_POST_PMD),
1201
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001202 /* TX */
Bradley Rubin229c6a52011-07-12 16:18:48 -07001203
Bradley Rubine1d08622011-07-20 18:01:35 -07001204 SND_SOC_DAPM_SUPPLY("CDC_CONN", TABLA_A_CDC_CLK_OTHR_CTL, 2, 0, NULL,
1205 0),
1206
Bradley Rubin229c6a52011-07-12 16:18:48 -07001207 SND_SOC_DAPM_SUPPLY("LDO_H", TABLA_A_LDO_H_MODE_1, 7, 0,
1208 tabla_codec_enable_ldo_h, SND_SOC_DAPM_POST_PMU),
1209
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001210 SND_SOC_DAPM_INPUT("AMIC1"),
1211 SND_SOC_DAPM_MICBIAS_E("MIC BIAS1 External", TABLA_A_MICB_1_CTL, 7, 0,
1212 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001213 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001214 SND_SOC_DAPM_MICBIAS_E("MIC BIAS1 Internal1", TABLA_A_MICB_1_CTL, 7, 0,
1215 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001216 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001217 SND_SOC_DAPM_MICBIAS_E("MIC BIAS1 Internal2", TABLA_A_MICB_1_CTL, 7, 0,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001218 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001219 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001220 SND_SOC_DAPM_ADC_E("ADC1", NULL, TABLA_A_TX_1_2_EN, 7, 0,
1221 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1222 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1223
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001224 SND_SOC_DAPM_INPUT("AMIC3"),
1225 SND_SOC_DAPM_ADC_E("ADC3", NULL, TABLA_A_TX_3_4_EN, 7, 0,
1226 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1227 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1228
1229 SND_SOC_DAPM_INPUT("AMIC4"),
1230 SND_SOC_DAPM_ADC_E("ADC4", NULL, TABLA_A_TX_3_4_EN, 3, 0,
1231 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1232 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1233
1234 SND_SOC_DAPM_MICBIAS_E("MIC BIAS4 External", TABLA_A_MICB_4_CTL, 7, 0,
1235 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001236 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001237
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001238 SND_SOC_DAPM_INPUT("AMIC5"),
1239 SND_SOC_DAPM_ADC_E("ADC5", NULL, TABLA_A_TX_5_6_EN, 7, 0,
1240 tabla_codec_enable_adc, SND_SOC_DAPM_POST_PMU),
1241
1242 SND_SOC_DAPM_INPUT("AMIC6"),
1243 SND_SOC_DAPM_ADC_E("ADC6", NULL, TABLA_A_TX_5_6_EN, 3, 0,
1244 tabla_codec_enable_adc, SND_SOC_DAPM_POST_PMU),
1245
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001246 SND_SOC_DAPM_MUX_E("DEC1 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 0, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001247 &dec1_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001248
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001249 SND_SOC_DAPM_MUX_E("DEC2 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 1, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001250 &dec2_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001251
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001252 SND_SOC_DAPM_MUX_E("DEC3 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 2, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001253 &dec3_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001254
1255 SND_SOC_DAPM_MUX_E("DEC4 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 3, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001256 &dec4_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001257
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001258 SND_SOC_DAPM_MUX_E("DEC5 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 4, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001259 &dec5_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001260
1261 SND_SOC_DAPM_MUX_E("DEC6 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 5, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001262 &dec6_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001263
1264 SND_SOC_DAPM_MUX_E("DEC7 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 6, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001265 &dec7_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001266
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001267 SND_SOC_DAPM_MUX_E("DEC8 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL, 7, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001268 &dec8_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001269
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001270 SND_SOC_DAPM_MUX_E("DEC9 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B2_CTL, 0, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001271 &dec9_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001272
1273 SND_SOC_DAPM_MUX_E("DEC10 MUX", TABLA_A_CDC_CLK_TX_CLK_EN_B2_CTL, 1, 0,
Bradley Rubine1d08622011-07-20 18:01:35 -07001274 &dec10_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001275
Bradley Rubin229c6a52011-07-12 16:18:48 -07001276 SND_SOC_DAPM_MUX("ANC1 MUX", SND_SOC_NOPM, 0, 0, &anc1_mux),
1277 SND_SOC_DAPM_MUX("ANC2 MUX", SND_SOC_NOPM, 0, 0, &anc2_mux),
1278
1279 SND_SOC_DAPM_MIXER_E("ANC", SND_SOC_NOPM, 0, 0, NULL, 0,
1280 tabla_codec_enable_anc, SND_SOC_DAPM_PRE_PMU |
1281 SND_SOC_DAPM_POST_PMD),
1282
1283 SND_SOC_DAPM_MUX("ANC1 FB MUX", SND_SOC_NOPM, 0, 0, &anc1_fb_mux),
1284
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001285 SND_SOC_DAPM_INPUT("AMIC2"),
1286 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 External", TABLA_A_MICB_2_CTL, 7, 0,
1287 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001288 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001289 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 Internal1", TABLA_A_MICB_2_CTL, 7, 0,
1290 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001291 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001292 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 Internal2", TABLA_A_MICB_2_CTL, 7, 0,
1293 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001294 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001295 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 Internal3", TABLA_A_MICB_2_CTL, 7, 0,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001296 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001297 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001298 SND_SOC_DAPM_MICBIAS_E("MIC BIAS3 External", TABLA_A_MICB_3_CTL, 7, 0,
1299 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001300 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001301 SND_SOC_DAPM_MICBIAS_E("MIC BIAS3 Internal1", TABLA_A_MICB_3_CTL, 7, 0,
1302 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001303 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001304 SND_SOC_DAPM_MICBIAS_E("MIC BIAS3 Internal2", TABLA_A_MICB_3_CTL, 7, 0,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001305 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001306 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001307 SND_SOC_DAPM_ADC_E("ADC2", NULL, TABLA_A_TX_1_2_EN, 3, 0,
1308 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1309 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1310
1311 SND_SOC_DAPM_MUX("SLIM TX1 MUX", SND_SOC_NOPM, 0, 0, &sb_tx1_mux),
1312 SND_SOC_DAPM_AIF_OUT("SLIM TX1", "AIF1 Capture", NULL, SND_SOC_NOPM,
1313 0, 0),
1314
1315 SND_SOC_DAPM_MUX("SLIM TX5 MUX", SND_SOC_NOPM, 0, 0, &sb_tx5_mux),
1316 SND_SOC_DAPM_AIF_OUT("SLIM TX5", "AIF1 Capture", NULL, SND_SOC_NOPM,
1317 4, 0),
1318
1319 SND_SOC_DAPM_MUX("SLIM TX6 MUX", SND_SOC_NOPM, 0, 0, &sb_tx6_mux),
1320 SND_SOC_DAPM_AIF_OUT("SLIM TX6", "AIF1 Capture", NULL, SND_SOC_NOPM,
1321 5, 0),
1322
1323 SND_SOC_DAPM_MUX("SLIM TX7 MUX", SND_SOC_NOPM, 0, 0, &sb_tx7_mux),
1324 SND_SOC_DAPM_AIF_OUT("SLIM TX7", "AIF1 Capture", NULL, SND_SOC_NOPM,
1325 0, 0),
1326
1327 SND_SOC_DAPM_MUX("SLIM TX8 MUX", SND_SOC_NOPM, 0, 0, &sb_tx8_mux),
1328 SND_SOC_DAPM_AIF_OUT("SLIM TX8", "AIF1 Capture", NULL, SND_SOC_NOPM,
1329 0, 0),
1330
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001331 /* Digital Mic Inputs */
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001332 SND_SOC_DAPM_ADC_E("DMIC1", NULL, SND_SOC_NOPM, 0, 0,
1333 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1334 SND_SOC_DAPM_POST_PMD),
1335
1336 SND_SOC_DAPM_ADC_E("DMIC2", NULL, SND_SOC_NOPM, 0, 0,
1337 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1338 SND_SOC_DAPM_POST_PMD),
1339
1340 SND_SOC_DAPM_ADC_E("DMIC3", NULL, SND_SOC_NOPM, 0, 0,
1341 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1342 SND_SOC_DAPM_POST_PMD),
1343
1344 SND_SOC_DAPM_ADC_E("DMIC4", NULL, SND_SOC_NOPM, 0, 0,
1345 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1346 SND_SOC_DAPM_POST_PMD),
1347
1348 SND_SOC_DAPM_ADC_E("DMIC5", NULL, SND_SOC_NOPM, 0, 0,
1349 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1350 SND_SOC_DAPM_POST_PMD),
1351
1352 SND_SOC_DAPM_ADC_E("DMIC6", NULL, SND_SOC_NOPM, 0, 0,
1353 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1354 SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001355
1356 /* Sidetone */
1357 SND_SOC_DAPM_MUX("IIR1 INP1 MUX", SND_SOC_NOPM, 0, 0, &iir1_inp1_mux),
1358 SND_SOC_DAPM_PGA("IIR1", TABLA_A_CDC_CLK_SD_CTL, 0, 0, NULL, 0),
1359};
1360
1361static const struct snd_soc_dapm_route audio_map[] = {
1362 /* SLIMBUS Connections */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001363
1364 {"SLIM TX1", NULL, "SLIM TX1 MUX"},
1365 {"SLIM TX1 MUX", "DEC1", "DEC1 MUX"},
1366
1367 {"SLIM TX5", NULL, "SLIM TX5 MUX"},
1368 {"SLIM TX5 MUX", "DEC5", "DEC5 MUX"},
1369
1370 {"SLIM TX6", NULL, "SLIM TX6 MUX"},
1371 {"SLIM TX6 MUX", "DEC6", "DEC6 MUX"},
1372
1373 {"SLIM TX7", NULL, "SLIM TX7 MUX"},
1374 {"SLIM TX7 MUX", "DEC1", "DEC1 MUX"},
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001375 {"SLIM TX7 MUX", "DEC2", "DEC2 MUX"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001376 {"SLIM TX7 MUX", "DEC3", "DEC3 MUX"},
1377 {"SLIM TX7 MUX", "DEC4", "DEC4 MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001378 {"SLIM TX7 MUX", "DEC5", "DEC5 MUX"},
1379 {"SLIM TX7 MUX", "DEC6", "DEC6 MUX"},
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001380 {"SLIM TX7 MUX", "DEC7", "DEC7 MUX"},
1381 {"SLIM TX7 MUX", "DEC8", "DEC8 MUX"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001382 {"SLIM TX7 MUX", "DEC9", "DEC9 MUX"},
1383 {"SLIM TX7 MUX", "DEC10", "DEC10 MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001384
1385 {"SLIM TX8", NULL, "SLIM TX8 MUX"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001386 {"SLIM TX8 MUX", "DEC1", "DEC1 MUX"},
1387 {"SLIM TX8 MUX", "DEC2", "DEC2 MUX"},
1388 {"SLIM TX8 MUX", "DEC3", "DEC3 MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001389 {"SLIM TX8 MUX", "DEC5", "DEC5 MUX"},
1390 {"SLIM TX8 MUX", "DEC6", "DEC6 MUX"},
1391
1392 /* Earpiece (RX MIX1) */
1393 {"EAR", NULL, "EAR PA"},
Kiran Kandiac034ac2011-07-29 16:39:08 -07001394 {"EAR PA", NULL, "DAC1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001395 {"DAC1", NULL, "CP"},
1396
1397 {"ANC1 FB MUX", "EAR_HPH_L", "RX1 MIX1"},
1398 {"ANC1 FB MUX", "EAR_LINE_1", "RX2 MIX1"},
1399 {"ANC", NULL, "ANC1 FB MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001400
1401 /* Headset (RX MIX1 and RX MIX2) */
1402 {"HEADPHONE", NULL, "HPHL"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001403 {"HEADPHONE", NULL, "HPHR"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001404
1405 {"HPHL", NULL, "HPHL DAC"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001406 {"HPHR", NULL, "HPHR DAC"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001407
1408 {"HPHL DAC", NULL, "CP"},
1409 {"HPHR DAC", NULL, "CP"},
1410
1411 {"ANC", NULL, "ANC1 MUX"},
1412 {"ANC", NULL, "ANC2 MUX"},
1413 {"ANC1 MUX", "ADC1", "ADC1"},
1414 {"ANC1 MUX", "ADC2", "ADC2"},
1415 {"ANC1 MUX", "ADC3", "ADC3"},
1416 {"ANC1 MUX", "ADC4", "ADC4"},
1417 {"ANC2 MUX", "ADC1", "ADC1"},
1418 {"ANC2 MUX", "ADC2", "ADC2"},
1419 {"ANC2 MUX", "ADC3", "ADC3"},
1420 {"ANC2 MUX", "ADC4", "ADC4"},
1421
Bradley Rubine1d08622011-07-20 18:01:35 -07001422 {"ANC", NULL, "CDC_CONN"},
1423
Bradley Rubin229c6a52011-07-12 16:18:48 -07001424 {"DAC1", "Switch", "RX1 CHAIN"},
1425 {"HPHL DAC", "Switch", "RX1 CHAIN"},
1426 {"HPHR DAC", "Switch", "RX2 CHAIN"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001427
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001428 {"LINEOUT1", NULL, "LINEOUT1 PA"},
1429 {"LINEOUT2", NULL, "LINEOUT2 PA"},
1430 {"LINEOUT3", NULL, "LINEOUT3 PA"},
1431 {"LINEOUT4", NULL, "LINEOUT4 PA"},
1432 {"LINEOUT5", NULL, "LINEOUT5 PA"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001433
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001434 {"LINEOUT1 PA", NULL, "LINEOUT1 DAC"},
1435 {"LINEOUT2 PA", NULL, "LINEOUT2 DAC"},
1436 {"LINEOUT3 PA", NULL, "LINEOUT3 DAC"},
1437 {"LINEOUT4 PA", NULL, "LINEOUT4 DAC"},
1438 {"LINEOUT5 PA", NULL, "LINEOUT5 DAC"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001439
Bradley Rubin229c6a52011-07-12 16:18:48 -07001440 {"RX1 CHAIN", NULL, "RX1 MIX1"},
1441 {"RX2 CHAIN", NULL, "RX2 MIX1"},
1442 {"RX1 CHAIN", NULL, "ANC"},
1443 {"RX2 CHAIN", NULL, "ANC"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001444 {"LINEOUT1 DAC", "Switch", "RX3 MIX1"},
1445 {"LINEOUT2 DAC", "Switch", "RX4 MIX1"},
Kiran Kandied246a92011-08-12 14:03:44 -07001446 {"LINEOUT3 DAC", "Switch", "RX3 MIX1"},
1447 {"LINEOUT4 DAC", "Switch", "RX4 MIX1"},
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001448 {"LINEOUT5 DAC", "Switch", "RX7 MIX1"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001449
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001450 {"CP", NULL, "RX_BIAS"},
1451 {"LINEOUT1 DAC", NULL, "RX_BIAS"},
1452 {"LINEOUT2 DAC", NULL, "RX_BIAS"},
1453 {"LINEOUT3 DAC", NULL, "RX_BIAS"},
1454 {"LINEOUT4 DAC", NULL, "RX_BIAS"},
1455
Bradley Rubin229c6a52011-07-12 16:18:48 -07001456 {"RX1 MIX1", NULL, "RX1 MIX1 INP1"},
1457 {"RX1 MIX1", NULL, "RX1 MIX1 INP2"},
1458 {"RX2 MIX1", NULL, "RX2 MIX1 INP1"},
1459 {"RX2 MIX1", NULL, "RX2 MIX1 INP2"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001460 {"RX3 MIX1", NULL, "RX3 MIX1 INP1"},
1461 {"RX3 MIX1", NULL, "RX3 MIX1 INP2"},
1462 {"RX4 MIX1", NULL, "RX4 MIX1 INP1"},
1463 {"RX4 MIX1", NULL, "RX4 MIX1 INP2"},
1464 {"RX5 MIX1", NULL, "RX5 MIX1 INP1"},
1465 {"RX5 MIX1", NULL, "RX5 MIX1 INP2"},
1466 {"RX6 MIX1", NULL, "RX6 MIX1 INP1"},
1467 {"RX6 MIX1", NULL, "RX6 MIX1 INP2"},
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001468 {"RX7 MIX1", NULL, "RX7 MIX1 INP1"},
1469 {"RX7 MIX1", NULL, "RX7 MIX1 INP2"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001470
Bradley Rubin229c6a52011-07-12 16:18:48 -07001471 {"RX1 MIX1 INP1", "RX1", "SLIM RX1"},
1472 {"RX1 MIX1 INP1", "RX2", "SLIM RX2"},
1473 {"RX1 MIX1 INP1", "IIR1", "IIR1"},
1474 {"RX1 MIX1 INP2", "RX1", "SLIM RX1"},
1475 {"RX1 MIX1 INP2", "RX2", "SLIM RX2"},
1476 {"RX1 MIX1 INP2", "IIR1", "IIR1"},
1477 {"RX2 MIX1 INP1", "RX1", "SLIM RX1"},
1478 {"RX2 MIX1 INP1", "RX2", "SLIM RX2"},
1479 {"RX2 MIX1 INP2", "RX1", "SLIM RX1"},
1480 {"RX2 MIX1 INP2", "RX2", "SLIM RX2"},
1481 {"RX3 MIX1 INP1", "RX1", "SLIM RX1"},
1482 {"RX3 MIX1 INP1", "RX2", "SLIM RX2"},
1483 {"RX3 MIX1 INP2", "RX1", "SLIM RX1"},
1484 {"RX3 MIX1 INP2", "RX2", "SLIM RX2"},
1485 {"RX4 MIX1 INP1", "RX1", "SLIM RX1"},
1486 {"RX4 MIX1 INP1", "RX2", "SLIM RX2"},
1487 {"RX4 MIX1 INP2", "RX1", "SLIM RX1"},
1488 {"RX4 MIX1 INP2", "RX2", "SLIM RX2"},
1489 {"RX5 MIX1 INP1", "RX1", "SLIM RX1"},
1490 {"RX5 MIX1 INP1", "RX2", "SLIM RX2"},
1491 {"RX5 MIX1 INP2", "RX1", "SLIM RX1"},
1492 {"RX5 MIX1 INP2", "RX2", "SLIM RX2"},
1493 {"RX6 MIX1 INP1", "RX1", "SLIM RX1"},
1494 {"RX6 MIX1 INP1", "RX2", "SLIM RX2"},
1495 {"RX6 MIX1 INP2", "RX1", "SLIM RX1"},
1496 {"RX6 MIX1 INP2", "RX2", "SLIM RX2"},
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001497 {"RX7 MIX1 INP1", "RX1", "SLIM RX1"},
1498 {"RX7 MIX1 INP1", "RX2", "SLIM RX2"},
1499 {"RX7 MIX1 INP2", "RX1", "SLIM RX1"},
1500 {"RX7 MIX1 INP2", "RX2", "SLIM RX2"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001501
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001502 /* Decimator Inputs */
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001503 {"DEC1 MUX", "DMIC1", "DMIC1"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001504 {"DEC1 MUX", "ADC6", "ADC6"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001505 {"DEC1 MUX", NULL, "CDC_CONN"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001506 {"DEC2 MUX", "DMIC2", "DMIC2"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001507 {"DEC2 MUX", "ADC5", "ADC5"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001508 {"DEC2 MUX", NULL, "CDC_CONN"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001509 {"DEC3 MUX", "DMIC3", "DMIC3"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001510 {"DEC3 MUX", "ADC4", "ADC4"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001511 {"DEC3 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001512 {"DEC4 MUX", "DMIC4", "DMIC4"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001513 {"DEC4 MUX", "ADC3", "ADC3"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001514 {"DEC4 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001515 {"DEC5 MUX", "DMIC5", "DMIC5"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001516 {"DEC5 MUX", "ADC2", "ADC2"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001517 {"DEC5 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001518 {"DEC6 MUX", "DMIC6", "DMIC6"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001519 {"DEC6 MUX", "ADC1", "ADC1"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001520 {"DEC6 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001521 {"DEC7 MUX", "DMIC1", "DMIC1"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001522 {"DEC7 MUX", "ADC6", "ADC6"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001523 {"DEC7 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001524 {"DEC8 MUX", "ADC5", "ADC5"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001525 {"DEC8 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001526 {"DEC9 MUX", "ADC3", "ADC3"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001527 {"DEC9 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001528 {"DEC10 MUX", "ADC4", "ADC4"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001529 {"DEC10 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001530
1531 /* ADC Connections */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001532 {"ADC1", NULL, "AMIC1"},
1533 {"ADC2", NULL, "AMIC2"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001534 {"ADC3", NULL, "AMIC3"},
1535 {"ADC4", NULL, "AMIC4"},
1536 {"ADC5", NULL, "AMIC5"},
1537 {"ADC6", NULL, "AMIC6"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001538
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001539 {"IIR1", NULL, "IIR1 INP1 MUX"},
1540 {"IIR1 INP1 MUX", "DEC6", "DEC6 MUX"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001541
1542 {"MIC BIAS1 Internal1", NULL, "LDO_H"},
1543 {"MIC BIAS1 Internal2", NULL, "LDO_H"},
1544 {"MIC BIAS1 External", NULL, "LDO_H"},
1545 {"MIC BIAS2 Internal1", NULL, "LDO_H"},
1546 {"MIC BIAS2 Internal2", NULL, "LDO_H"},
1547 {"MIC BIAS2 Internal3", NULL, "LDO_H"},
1548 {"MIC BIAS2 External", NULL, "LDO_H"},
1549 {"MIC BIAS3 Internal1", NULL, "LDO_H"},
1550 {"MIC BIAS3 Internal2", NULL, "LDO_H"},
1551 {"MIC BIAS3 External", NULL, "LDO_H"},
1552 {"MIC BIAS4 External", NULL, "LDO_H"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001553};
1554
1555static int tabla_readable(struct snd_soc_codec *ssc, unsigned int reg)
1556{
1557 return tabla_reg_readable[reg];
1558}
1559
1560static int tabla_volatile(struct snd_soc_codec *ssc, unsigned int reg)
1561{
1562 /* Registers lower than 0x100 are top level registers which can be
1563 * written by the Tabla core driver.
1564 */
1565
1566 if ((reg >= TABLA_A_CDC_MBHC_EN_CTL) || (reg < 0x100))
1567 return 1;
1568
1569 return 0;
1570}
1571
1572#define TABLA_FORMATS (SNDRV_PCM_FMTBIT_S16_LE)
1573static int tabla_write(struct snd_soc_codec *codec, unsigned int reg,
1574 unsigned int value)
1575{
1576 int ret;
1577 pr_debug("%s: write reg %x val %x\n", __func__, reg, value);
1578
1579 BUG_ON(reg > TABLA_MAX_REGISTER);
1580
1581 if (!tabla_volatile(codec, reg)) {
1582 pr_debug("writing to cache\n");
1583 ret = snd_soc_cache_write(codec, reg, value);
1584 if (ret != 0)
1585 dev_err(codec->dev, "Cache write to %x failed: %d\n",
1586 reg, ret);
1587 }
1588
1589 return tabla_reg_write(codec->control_data, reg, value);
1590}
1591static unsigned int tabla_read(struct snd_soc_codec *codec,
1592 unsigned int reg)
1593{
1594 unsigned int val;
1595 int ret;
1596
1597 BUG_ON(reg > TABLA_MAX_REGISTER);
1598
1599 if (!tabla_volatile(codec, reg) && tabla_readable(codec, reg) &&
1600 reg < codec->driver->reg_cache_size) {
1601 pr_debug("reading from cache\n");
1602 ret = snd_soc_cache_read(codec, reg, &val);
1603 if (ret >= 0) {
Bradley Rubin229c6a52011-07-12 16:18:48 -07001604 pr_debug("register %x, value %x\n", reg, val);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001605 return val;
1606 } else
1607 dev_err(codec->dev, "Cache read from %x failed: %d\n",
1608 reg, ret);
1609 }
1610
1611 val = tabla_reg_read(codec->control_data, reg);
1612 pr_debug("%s: read reg %x val %x\n", __func__, reg, val);
1613 return val;
1614}
1615
1616static void tabla_codec_enable_audio_mode_bandgap(struct snd_soc_codec *codec)
1617{
1618 snd_soc_write(codec, TABLA_A_BIAS_REF_CTL, 0x1C);
1619 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
1620 0x80);
1621 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x04,
1622 0x04);
1623 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x01,
1624 0x01);
1625 usleep_range(1000, 1000);
1626 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
1627 0x00);
1628}
1629
1630static void tabla_codec_enable_bandgap(struct snd_soc_codec *codec,
1631 enum tabla_bandgap_type choice)
1632{
1633 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1634
1635 /* TODO lock resources accessed by audio streams and threaded
1636 * interrupt handlers
1637 */
1638
1639 pr_debug("%s, choice is %d, current is %d\n", __func__, choice,
1640 tabla->bandgap_type);
1641
1642 if (tabla->bandgap_type == choice)
1643 return;
1644
1645 if ((tabla->bandgap_type == TABLA_BANDGAP_OFF) &&
1646 (choice == TABLA_BANDGAP_AUDIO_MODE)) {
1647 tabla_codec_enable_audio_mode_bandgap(codec);
1648 } else if ((tabla->bandgap_type == TABLA_BANDGAP_AUDIO_MODE) &&
1649 (choice == TABLA_BANDGAP_MBHC_MODE)) {
1650 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x2,
1651 0x2);
1652 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
1653 0x80);
1654 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x4,
1655 0x4);
1656 usleep_range(1000, 1000);
1657 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
1658 0x00);
1659 } else if ((tabla->bandgap_type == TABLA_BANDGAP_MBHC_MODE) &&
1660 (choice == TABLA_BANDGAP_AUDIO_MODE)) {
1661 snd_soc_write(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x00);
1662 usleep_range(100, 100);
1663 tabla_codec_enable_audio_mode_bandgap(codec);
1664 } else if (choice == TABLA_BANDGAP_OFF) {
1665 snd_soc_write(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x00);
1666 } else {
1667 pr_err("%s: Error, Invalid bandgap settings\n", __func__);
1668 }
1669 tabla->bandgap_type = choice;
1670}
1671
1672static int tabla_codec_enable_config_mode(struct snd_soc_codec *codec,
1673 int enable)
1674{
1675 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1676
1677 if (enable) {
1678 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_FREQ, 0x10, 0);
1679 snd_soc_write(codec, TABLA_A_BIAS_CONFIG_MODE_BG_CTL, 0x17);
1680 usleep_range(5, 5);
1681 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_FREQ, 0x80,
1682 0x80);
1683 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_TEST, 0x80,
1684 0x80);
1685 usleep_range(10, 10);
1686 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_TEST, 0x80, 0);
1687 usleep_range(20, 20);
1688 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x08, 0x08);
1689 } else {
1690 snd_soc_update_bits(codec, TABLA_A_BIAS_CONFIG_MODE_BG_CTL, 0x1,
1691 0);
1692 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_FREQ, 0x80, 0);
1693 }
1694 tabla->config_mode_active = enable ? true : false;
1695
1696 return 0;
1697}
1698
1699static int tabla_codec_enable_clock_block(struct snd_soc_codec *codec,
1700 int config_mode)
1701{
1702 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1703
1704 pr_debug("%s\n", __func__);
1705
1706 if (config_mode) {
1707 tabla_codec_enable_config_mode(codec, 1);
1708 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN2, 0x00);
1709 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN2, 0x02);
1710 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN1, 0x0D);
1711 usleep_range(1000, 1000);
1712 } else
1713 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x08, 0x00);
1714
1715 if (!config_mode && tabla->mbhc_polling_active) {
1716 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN2, 0x02);
1717 tabla_codec_enable_config_mode(codec, 0);
1718
1719 }
1720
1721 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x05, 0x05);
1722 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x02, 0x00);
1723 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x04, 0x04);
1724 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_MCLK_CTL, 0x01, 0x01);
1725 usleep_range(50, 50);
1726 tabla->clock_active = true;
1727 return 0;
1728}
1729static void tabla_codec_disable_clock_block(struct snd_soc_codec *codec)
1730{
1731 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1732 pr_debug("%s\n", __func__);
1733 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x04, 0x00);
1734 ndelay(160);
1735 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x02, 0x02);
1736 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x05, 0x00);
1737 tabla->clock_active = false;
1738}
1739
Bradley Rubincb1e2732011-06-23 16:49:20 -07001740static void tabla_codec_calibrate_hs_polling(struct snd_soc_codec *codec)
1741{
1742 /* TODO store register values in calibration */
1743
1744 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B10_CTL, 0xFF);
1745 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B9_CTL, 0x00);
1746
1747 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B4_CTL, 0x08);
1748 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B3_CTL, 0xEE);
1749 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B2_CTL, 0xFC);
1750 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B1_CTL, 0xCE);
1751
1752 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B1_CTL, 3);
1753 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B2_CTL, 9);
1754 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B3_CTL, 30);
1755 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B6_CTL, 120);
1756 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_TIMER_B1_CTL, 0x78, 0x58);
1757 snd_soc_write(codec, TABLA_A_CDC_MBHC_B2_CTL, 11);
1758}
1759
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001760static int tabla_startup(struct snd_pcm_substream *substream,
1761 struct snd_soc_dai *dai)
1762{
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001763 pr_debug("%s(): substream = %s stream = %d\n" , __func__,
1764 substream->name, substream->stream);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001765
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001766 return 0;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001767}
1768
1769static void tabla_shutdown(struct snd_pcm_substream *substream,
1770 struct snd_soc_dai *dai)
1771{
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001772 pr_debug("%s(): substream = %s stream = %d\n" , __func__,
1773 substream->name, substream->stream);
1774}
1775
1776int tabla_mclk_enable(struct snd_soc_codec *codec, int mclk_enable)
1777{
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001778 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1779
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001780 pr_debug("%s() mclk_enable = %u\n", __func__, mclk_enable);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001781
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001782 if (mclk_enable) {
1783 tabla->mclk_enabled = true;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001784
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001785 if (tabla->mbhc_polling_active && (tabla->mclk_enabled)) {
Bradley Rubincb1e2732011-06-23 16:49:20 -07001786 tabla_codec_pause_hs_polling(codec);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001787 tabla_codec_enable_bandgap(codec,
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001788 TABLA_BANDGAP_AUDIO_MODE);
1789 tabla_codec_enable_clock_block(codec, 0);
Bradley Rubincb1e2732011-06-23 16:49:20 -07001790 tabla_codec_calibrate_hs_polling(codec);
1791 tabla_codec_start_hs_polling(codec);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001792 }
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001793 } else {
1794
1795 if (!tabla->mclk_enabled) {
1796 pr_err("Error, MCLK already diabled\n");
1797 return -EINVAL;
1798 }
1799 tabla->mclk_enabled = false;
1800
1801 if (tabla->mbhc_polling_active) {
1802 if (!tabla->mclk_enabled) {
1803 tabla_codec_pause_hs_polling(codec);
1804 tabla_codec_enable_bandgap(codec,
1805 TABLA_BANDGAP_MBHC_MODE);
1806 tabla_enable_rx_bias(codec, 1);
1807 tabla_codec_enable_clock_block(codec, 1);
1808 tabla_codec_calibrate_hs_polling(codec);
1809 tabla_codec_start_hs_polling(codec);
1810 }
1811 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1,
1812 0x05, 0x01);
1813 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001814 }
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001815 return 0;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001816}
1817
1818static int tabla_digital_mute(struct snd_soc_dai *codec_dai, int mute)
1819{
1820 struct snd_soc_codec *codec = codec_dai->codec;
1821
1822 pr_debug("%s %d\n", __func__, mute);
1823
1824 /* TODO mute TX */
1825 if (mute)
1826 snd_soc_update_bits(codec, TABLA_A_CDC_RX1_B6_CTL, 0x01, 0x01);
1827 else
1828 snd_soc_update_bits(codec, TABLA_A_CDC_RX1_B6_CTL, 0x01, 0x00);
1829
1830 return 0;
1831}
1832
1833static int tabla_set_dai_sysclk(struct snd_soc_dai *dai,
1834 int clk_id, unsigned int freq, int dir)
1835{
1836 pr_debug("%s\n", __func__);
1837 return 0;
1838}
1839
1840static int tabla_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
1841{
1842 pr_debug("%s\n", __func__);
1843 return 0;
1844}
1845
1846static int tabla_hw_params(struct snd_pcm_substream *substream,
1847 struct snd_pcm_hw_params *params,
1848 struct snd_soc_dai *dai)
1849{
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07001850 struct snd_soc_codec *codec = dai->codec;
Bhalchandra Gajare038bf3a2011-09-02 15:32:30 -07001851 u8 path, shift;
1852 u16 tx_fs_reg, rx_fs_reg;
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07001853 u8 tx_fs_rate, rx_fs_rate, rx_state, tx_state;
1854
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001855 pr_debug("%s: DAI-ID %x\n", __func__, dai->id);
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07001856
1857 switch (params_rate(params)) {
1858 case 8000:
1859 tx_fs_rate = 0x00;
1860 rx_fs_rate = 0x00;
1861 break;
1862 case 16000:
1863 tx_fs_rate = 0x01;
1864 rx_fs_rate = 0x20;
1865 break;
1866 case 32000:
1867 tx_fs_rate = 0x02;
1868 rx_fs_rate = 0x40;
1869 break;
1870 case 48000:
1871 tx_fs_rate = 0x03;
1872 rx_fs_rate = 0x60;
1873 break;
1874 default:
1875 pr_err("%s: Invalid sampling rate %d\n", __func__,
1876 params_rate(params));
1877 return -EINVAL;
1878 }
1879
1880
1881 /**
1882 * If current dai is a tx dai, set sample rate to
1883 * all the txfe paths that are currently not active
1884 */
1885 if (dai->id == TABLA_TX_DAI_ID) {
1886
1887 tx_state = snd_soc_read(codec,
1888 TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL);
1889
1890 for (path = 1, shift = 0;
1891 path <= NUM_DECIMATORS; path++, shift++) {
1892
1893 if (path == BITS_PER_REG + 1) {
1894 shift = 0;
1895 tx_state = snd_soc_read(codec,
1896 TABLA_A_CDC_CLK_TX_CLK_EN_B2_CTL);
1897 }
1898
1899 if (!(tx_state & (1 << shift))) {
1900 tx_fs_reg = TABLA_A_CDC_TX1_CLK_FS_CTL
1901 + (BITS_PER_REG*(path-1));
1902 snd_soc_update_bits(codec, tx_fs_reg,
1903 0x03, tx_fs_rate);
1904 }
1905 }
1906 }
1907
1908 /**
1909 * TODO: Need to handle case where same RX chain takes 2 or more inputs
1910 * with varying sample rates
1911 */
1912
1913 /**
1914 * If current dai is a rx dai, set sample rate to
1915 * all the rx paths that are currently not active
1916 */
1917 if (dai->id == TABLA_RX_DAI_ID) {
1918
1919 rx_state = snd_soc_read(codec,
1920 TABLA_A_CDC_CLK_RX_B1_CTL);
1921
1922 for (path = 1, shift = 0;
1923 path <= NUM_INTERPOLATORS; path++, shift++) {
1924
1925 if (!(rx_state & (1 << shift))) {
1926 rx_fs_reg = TABLA_A_CDC_RX1_B5_CTL
1927 + (BITS_PER_REG*(path-1));
1928 snd_soc_update_bits(codec, rx_fs_reg,
1929 0xE0, rx_fs_rate);
1930 }
1931 }
1932 }
1933
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001934 return 0;
1935}
1936
1937static struct snd_soc_dai_ops tabla_dai_ops = {
1938 .startup = tabla_startup,
1939 .shutdown = tabla_shutdown,
1940 .hw_params = tabla_hw_params,
1941 .set_sysclk = tabla_set_dai_sysclk,
1942 .set_fmt = tabla_set_dai_fmt,
1943 .digital_mute = tabla_digital_mute,
1944};
1945
1946static struct snd_soc_dai_driver tabla_dai[] = {
1947 {
1948 .name = "tabla_rx1",
1949 .id = 1,
1950 .playback = {
1951 .stream_name = "AIF1 Playback",
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07001952 .rates = WCD9310_RATES,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001953 .formats = TABLA_FORMATS,
1954 .rate_max = 48000,
1955 .rate_min = 8000,
1956 .channels_min = 1,
1957 .channels_max = 2,
1958 },
1959 .ops = &tabla_dai_ops,
1960 },
1961 {
1962 .name = "tabla_tx1",
1963 .id = 2,
1964 .capture = {
1965 .stream_name = "AIF1 Capture",
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07001966 .rates = WCD9310_RATES,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001967 .formats = TABLA_FORMATS,
1968 .rate_max = 48000,
1969 .rate_min = 8000,
1970 .channels_min = 1,
1971 .channels_max = 2,
1972 },
1973 .ops = &tabla_dai_ops,
1974 },
1975};
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07001976static short tabla_codec_read_sta_result(struct snd_soc_codec *codec)
Bradley Rubincb1e2732011-06-23 16:49:20 -07001977{
1978 u8 bias_msb, bias_lsb;
1979 short bias_value;
1980
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07001981 bias_msb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B3_STATUS);
1982 bias_lsb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B2_STATUS);
1983 bias_value = (bias_msb << 8) | bias_lsb;
1984 return bias_value;
1985}
1986
1987static short tabla_codec_read_dce_result(struct snd_soc_codec *codec)
1988{
1989 u8 bias_msb, bias_lsb;
1990 short bias_value;
1991
1992 bias_msb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B5_STATUS);
1993 bias_lsb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B4_STATUS);
1994 bias_value = (bias_msb << 8) | bias_lsb;
1995 return bias_value;
1996}
1997
1998static short tabla_codec_measure_micbias_voltage(struct snd_soc_codec *codec,
1999 int dce)
2000{
2001 short bias_value;
2002
Bradley Rubincb1e2732011-06-23 16:49:20 -07002003 if (dce) {
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002004 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2005 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x4);
2006 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x0);
2007 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x4);
2008 usleep_range(60000, 60000);
2009 bias_value = tabla_codec_read_dce_result(codec);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002010 } else {
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002011 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002012 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x2);
2013 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x0);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002014 usleep_range(5000, 5000);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002015 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x2);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002016 usleep_range(50, 50);
2017 bias_value = tabla_codec_read_sta_result(codec);
2018 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2019 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x0);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002020 }
2021
Bradley Rubincb1e2732011-06-23 16:49:20 -07002022 pr_debug("read microphone bias value %x\n", bias_value);
2023 return bias_value;
2024}
2025
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002026static short tabla_codec_setup_hs_polling(struct snd_soc_codec *codec)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002027{
2028 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2029 struct tabla_mbhc_calibration *calibration = tabla->calibration;
Patrick Lai3043fba2011-08-01 14:15:57 -07002030 int micbias_ctl_reg, micbias_cfilt_ctl_reg,
Bradley Rubincb1e2732011-06-23 16:49:20 -07002031 micbias_mbhc_reg;
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002032 short bias_value;
Patrick Lai3043fba2011-08-01 14:15:57 -07002033 unsigned int cfilt_sel;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002034
2035 if (!calibration) {
2036 pr_err("Error, no tabla calibration\n");
Bradley Rubincb1e2732011-06-23 16:49:20 -07002037 return -ENODEV;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002038 }
2039
2040 tabla->mbhc_polling_active = true;
2041
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002042 if (!tabla->mclk_enabled) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002043 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_MBHC_MODE);
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002044 tabla_enable_rx_bias(codec, 1);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002045 tabla_codec_enable_clock_block(codec, 1);
2046 }
2047
2048 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x05, 0x01);
2049
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002050 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS, 0xE0, 0xE0);
2051
Patrick Lai3043fba2011-08-01 14:15:57 -07002052 /* select cfilt separately from the micbias line in the platform data */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002053 switch (calibration->bias) {
2054 case TABLA_MICBIAS1:
2055 micbias_ctl_reg = TABLA_A_MICB_1_CTL;
Patrick Lai3043fba2011-08-01 14:15:57 -07002056 cfilt_sel = tabla->pdata->micbias.bias1_cfilt_sel;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002057 micbias_mbhc_reg = TABLA_A_MICB_1_MBHC;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002058 break;
2059 case TABLA_MICBIAS2:
2060 micbias_ctl_reg = TABLA_A_MICB_2_CTL;
Patrick Lai3043fba2011-08-01 14:15:57 -07002061 cfilt_sel = tabla->pdata->micbias.bias2_cfilt_sel;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002062 micbias_mbhc_reg = TABLA_A_MICB_2_MBHC;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002063 break;
2064 case TABLA_MICBIAS3:
2065 micbias_ctl_reg = TABLA_A_MICB_3_CTL;
Patrick Lai3043fba2011-08-01 14:15:57 -07002066 cfilt_sel = tabla->pdata->micbias.bias3_cfilt_sel;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002067 micbias_mbhc_reg = TABLA_A_MICB_3_MBHC;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002068 break;
2069 case TABLA_MICBIAS4:
2070 pr_err("%s: Error, microphone bias 4 not supported\n",
2071 __func__);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002072 return -EINVAL;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002073 default:
2074 pr_err("Error, invalid mic bias line\n");
Bradley Rubincb1e2732011-06-23 16:49:20 -07002075 return -EINVAL;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002076 }
Patrick Lai3043fba2011-08-01 14:15:57 -07002077
2078 switch (cfilt_sel) {
2079 case TABLA_CFILT1_SEL:
2080 micbias_cfilt_ctl_reg = TABLA_A_MICB_CFILT_1_CTL;
2081 break;
2082 case TABLA_CFILT2_SEL:
2083 micbias_cfilt_ctl_reg = TABLA_A_MICB_CFILT_2_CTL;
2084 break;
2085 case TABLA_CFILT3_SEL:
2086 micbias_cfilt_ctl_reg = TABLA_A_MICB_CFILT_3_CTL;
2087 break;
2088 default: /* default should not happen as check should have been done */
2089 return -EINVAL;
2090 }
2091
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002092 snd_soc_write(codec, micbias_cfilt_ctl_reg, 0x00);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002093
Bradley Rubincb1e2732011-06-23 16:49:20 -07002094 snd_soc_update_bits(codec, micbias_ctl_reg, 0x1F, 0x16);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002095
2096 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x2, 0x2);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002097 snd_soc_write(codec, TABLA_A_MBHC_SCALING_MUX_1, 0x84);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002098
2099 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_EN, 0x80, 0x80);
2100 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_EN, 0x1F, 0x1C);
2101 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_TEST_CTL, 0x40, 0x40);
2102
2103 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_EN, 0x80, 0x00);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002104 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2105 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x00);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002106
Bradley Rubincb1e2732011-06-23 16:49:20 -07002107 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL, 0x6, 0x6);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002108 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2109
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002110 snd_soc_update_bits(codec, micbias_mbhc_reg, 0x10, 0x10);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002111 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x13, 0x01);
2112
2113 tabla_codec_calibrate_hs_polling(codec);
2114
2115 bias_value = tabla_codec_measure_micbias_voltage(codec, 0);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002116 snd_soc_write(codec, micbias_cfilt_ctl_reg, 0x40);
2117 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x13, 0x00);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002118
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002119 return bias_value;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002120}
2121
2122static int tabla_codec_enable_hs_detect(struct snd_soc_codec *codec,
2123 int insertion)
2124{
2125 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2126 struct tabla_mbhc_calibration *calibration = tabla->calibration;
2127 int central_bias_enabled = 0;
2128 int micbias_int_reg, micbias_ctl_reg, micbias_mbhc_reg;
2129
2130 if (!calibration) {
2131 pr_err("Error, no tabla calibration\n");
2132 return -EINVAL;
2133 }
2134
2135 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x1, 0);
2136
2137 if (insertion)
2138 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x2, 0);
2139 else
2140 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x2, 0x2);
2141
2142 if (snd_soc_read(codec, TABLA_A_CDC_MBHC_B1_CTL) & 0x4) {
2143 if (!(tabla->clock_active)) {
2144 tabla_codec_enable_config_mode(codec, 1);
2145 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL,
Bradley Rubincb1e2732011-06-23 16:49:20 -07002146 0x06, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002147 usleep_range(calibration->shutdown_plug_removal,
2148 calibration->shutdown_plug_removal);
2149 tabla_codec_enable_config_mode(codec, 0);
2150 } else
2151 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL,
Bradley Rubincb1e2732011-06-23 16:49:20 -07002152 0x06, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002153 }
2154
2155 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0xC,
2156 calibration->hph_current << 2);
2157
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002158 /* Turn off HPH PAs during insertion detection to avoid false
2159 * insertion interrupts
2160 */
2161 snd_soc_update_bits(codec, TABLA_A_RX_HPH_CNP_EN, 0x30, 0x00);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002162 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x13, 0x13);
2163
2164 switch (calibration->bias) {
2165 case TABLA_MICBIAS1:
2166 micbias_mbhc_reg = TABLA_A_MICB_1_MBHC;
2167 micbias_int_reg = TABLA_A_MICB_1_INT_RBIAS;
2168 micbias_ctl_reg = TABLA_A_MICB_1_CTL;
2169 break;
2170 case TABLA_MICBIAS2:
2171 micbias_mbhc_reg = TABLA_A_MICB_2_MBHC;
2172 micbias_int_reg = TABLA_A_MICB_2_INT_RBIAS;
2173 micbias_ctl_reg = TABLA_A_MICB_2_CTL;
2174 break;
2175 case TABLA_MICBIAS3:
2176 micbias_mbhc_reg = TABLA_A_MICB_3_MBHC;
2177 micbias_int_reg = TABLA_A_MICB_3_INT_RBIAS;
2178 micbias_ctl_reg = TABLA_A_MICB_3_CTL;
2179 break;
2180 case TABLA_MICBIAS4:
2181 micbias_mbhc_reg = TABLA_A_MICB_4_MBHC;
2182 micbias_int_reg = TABLA_A_MICB_4_INT_RBIAS;
2183 micbias_ctl_reg = TABLA_A_MICB_4_CTL;
2184 break;
2185 default:
2186 pr_err("Error, invalid mic bias line\n");
2187 return -EINVAL;
2188 }
2189 snd_soc_update_bits(codec, micbias_int_reg, 0x80, 0);
2190 snd_soc_update_bits(codec, micbias_ctl_reg, 0x1, 0);
2191
2192 /* If central bandgap disabled */
2193 if (!(snd_soc_read(codec, TABLA_A_PIN_CTL_OE1) & 1)) {
2194 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE1, 0x3, 0x3);
2195 usleep_range(calibration->bg_fast_settle,
2196 calibration->bg_fast_settle);
2197 central_bias_enabled = 1;
2198 }
2199
2200 /* If LDO_H disabled */
2201 if (snd_soc_read(codec, TABLA_A_PIN_CTL_OE0) & 0x80) {
2202 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE0, 0x10, 0);
2203 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE0, 0x80, 0x80);
2204 usleep_range(calibration->tldoh, calibration->tldoh);
2205 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE0, 0x80, 0);
2206
2207 if (central_bias_enabled)
2208 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE1, 0x1, 0);
2209 }
2210 snd_soc_update_bits(codec, micbias_mbhc_reg, 0x60,
2211 calibration->mic_current << 5);
2212 snd_soc_update_bits(codec, micbias_mbhc_reg, 0x80, 0x80);
2213 usleep_range(calibration->mic_pid, calibration->mic_pid);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002214
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002215 snd_soc_update_bits(codec, micbias_mbhc_reg, 0x10, 0x10);
2216
2217 snd_soc_update_bits(codec, TABLA_A_MICB_4_MBHC, 0x3, calibration->bias);
2218
2219 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION);
2220 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x1, 0x1);
2221 return 0;
2222}
2223
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002224static void btn0_lpress_fn(struct work_struct *work)
2225{
2226 struct delayed_work *delayed_work;
2227 struct tabla_priv *tabla;
2228
2229 pr_debug("%s:\n", __func__);
2230
2231 delayed_work = to_delayed_work(work);
2232 tabla = container_of(delayed_work, struct tabla_priv, btn0_dwork);
2233
2234 if (tabla) {
2235 if (tabla->button_jack) {
2236 pr_debug("%s: Reporting long button press event\n",
2237 __func__);
2238 snd_soc_jack_report(tabla->button_jack, SND_JACK_BTN_0,
2239 SND_JACK_BTN_0);
2240 }
2241 } else {
2242 pr_err("%s: Bad tabla private data\n", __func__);
2243 }
2244
2245}
Bradley Rubincb1e2732011-06-23 16:49:20 -07002246int tabla_hs_detect(struct snd_soc_codec *codec,
2247 struct snd_soc_jack *headset_jack, struct snd_soc_jack *button_jack,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002248 struct tabla_mbhc_calibration *calibration)
2249{
2250 struct tabla_priv *tabla;
2251 if (!codec || !calibration) {
2252 pr_err("Error: no codec or calibration\n");
2253 return -EINVAL;
2254 }
2255 tabla = snd_soc_codec_get_drvdata(codec);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002256 tabla->headset_jack = headset_jack;
2257 tabla->button_jack = button_jack;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002258 tabla->calibration = calibration;
2259
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002260 INIT_DELAYED_WORK(&tabla->btn0_dwork, btn0_lpress_fn);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002261 return tabla_codec_enable_hs_detect(codec, 1);
2262}
2263EXPORT_SYMBOL_GPL(tabla_hs_detect);
2264
Bradley Rubincb1e2732011-06-23 16:49:20 -07002265static irqreturn_t tabla_dce_handler(int irq, void *data)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002266{
2267 struct tabla_priv *priv = data;
2268 struct snd_soc_codec *codec = priv->codec;
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002269 short bias_value;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002270
2271 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
2272 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
2273
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002274 bias_value = tabla_codec_read_dce_result(codec);
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002275 pr_debug("%s: button press interrupt, bias value is %d\n",
2276 __func__, bias_value);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002277
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002278 /*
2279 * TODO: If button pressed is not button 0,
2280 * report the button press event immediately.
2281 */
2282 priv->buttons_pressed |= SND_JACK_BTN_0;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002283
Bradley Rubin688c66a2011-08-16 12:25:13 -07002284 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B4_CTL, 0x09);
2285 msleep(100);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002286
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002287 schedule_delayed_work(&priv->btn0_dwork, msecs_to_jiffies(400));
2288
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002289 return IRQ_HANDLED;
2290}
2291
Bradley Rubincb1e2732011-06-23 16:49:20 -07002292static irqreturn_t tabla_release_handler(int irq, void *data)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002293{
2294 struct tabla_priv *priv = data;
2295 struct snd_soc_codec *codec = priv->codec;
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002296 int ret, mic_voltage;
2297
Bradley Rubin4d09cf42011-08-17 17:59:16 -07002298 pr_debug("%s\n", __func__);
2299 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002300
Bradley Rubincb1e2732011-06-23 16:49:20 -07002301 if (priv->buttons_pressed & SND_JACK_BTN_0) {
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002302 ret = cancel_delayed_work(&priv->btn0_dwork);
2303
2304 if (ret == 0) {
2305
2306 pr_debug("%s: Reporting long button release event\n",
2307 __func__);
2308 if (priv->button_jack) {
2309 snd_soc_jack_report(priv->button_jack, 0,
2310 SND_JACK_BTN_0);
2311 }
2312
2313 } else {
2314
2315 mic_voltage =
2316 tabla_codec_measure_micbias_voltage(codec, 0);
2317 pr_debug("%s: Microphone Voltage on release = %d\n",
2318 __func__, mic_voltage);
2319
2320 if (mic_voltage < -2000 || mic_voltage > -670) {
2321 pr_debug("%s: Fake buttton press interrupt\n",
2322 __func__);
2323 } else {
2324
2325 if (priv->button_jack) {
2326 pr_debug("%s:reporting short button press and release\n",
2327 __func__);
2328
2329 snd_soc_jack_report(priv->button_jack,
2330 SND_JACK_BTN_0, SND_JACK_BTN_0);
2331 snd_soc_jack_report(priv->button_jack,
2332 0, SND_JACK_BTN_0);
2333 }
2334 }
2335 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002336
Bradley Rubincb1e2732011-06-23 16:49:20 -07002337 priv->buttons_pressed &= ~SND_JACK_BTN_0;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002338 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002339
Bradley Rubin688c66a2011-08-16 12:25:13 -07002340 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B4_CTL, 0x08);
2341 tabla_codec_start_hs_polling(codec);
2342
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002343 return IRQ_HANDLED;
2344}
2345
Bradley Rubincb1e2732011-06-23 16:49:20 -07002346static void tabla_codec_shutdown_hs_removal_detect(struct snd_soc_codec *codec)
2347{
2348 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2349 struct tabla_mbhc_calibration *calibration = tabla->calibration;
2350 int micbias_mbhc_reg;
2351
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002352 if (!tabla->mclk_enabled && !tabla->mbhc_polling_active)
Bradley Rubincb1e2732011-06-23 16:49:20 -07002353 tabla_codec_enable_config_mode(codec, 1);
2354
2355 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x2, 0x2);
2356 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL, 0x6, 0x0);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002357
2358 switch (calibration->bias) {
2359 case TABLA_MICBIAS1:
2360 micbias_mbhc_reg = TABLA_A_MICB_1_MBHC;
2361 break;
2362 case TABLA_MICBIAS2:
2363 micbias_mbhc_reg = TABLA_A_MICB_2_MBHC;
2364 break;
2365 case TABLA_MICBIAS3:
2366 micbias_mbhc_reg = TABLA_A_MICB_3_MBHC;
2367 break;
2368 case TABLA_MICBIAS4:
2369 micbias_mbhc_reg = TABLA_A_MICB_4_MBHC;
2370 break;
2371 default:
2372 pr_err("Error, invalid mic bias line\n");
2373 return;
2374 }
2375 snd_soc_update_bits(codec, micbias_mbhc_reg, 0x80, 0x00);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002376 usleep_range(calibration->shutdown_plug_removal,
2377 calibration->shutdown_plug_removal);
2378
2379 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0xA, 0x8);
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002380 if (!tabla->mclk_enabled && !tabla->mbhc_polling_active)
Bradley Rubincb1e2732011-06-23 16:49:20 -07002381 tabla_codec_enable_config_mode(codec, 0);
2382
2383 snd_soc_write(codec, TABLA_A_MBHC_SCALING_MUX_1, 0x00);
2384}
2385
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002386static void tabla_codec_shutdown_hs_polling(struct snd_soc_codec *codec)
2387{
2388 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002389
2390 tabla_codec_shutdown_hs_removal_detect(codec);
2391
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002392 if (!tabla->mclk_enabled) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002393 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS, 0xE0, 0x00);
2394 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_AUDIO_MODE);
2395 tabla_codec_enable_clock_block(codec, 0);
2396 }
2397
2398 tabla->mbhc_polling_active = false;
2399}
2400
Bradley Rubincb1e2732011-06-23 16:49:20 -07002401static irqreturn_t tabla_hs_insert_irq(int irq, void *data)
2402{
2403 struct tabla_priv *priv = data;
2404 struct snd_soc_codec *codec = priv->codec;
Bradley Rubin355611a2011-08-24 14:01:18 -07002405 int ldo_h_on, micb_cfilt_on;
2406 int micbias_cfilt_ctl_reg, cfilt_sel;
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002407 short mic_voltage;
2408 short threshold_no_mic = 0xF7F6;
2409 short threshold_fake_insert = 0xFD30;
2410
Bradley Rubincb1e2732011-06-23 16:49:20 -07002411
Bradley Rubin4d09cf42011-08-17 17:59:16 -07002412 pr_debug("%s\n", __func__);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002413 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION);
2414
Bradley Rubin355611a2011-08-24 14:01:18 -07002415 switch (priv->calibration->bias) {
2416 case TABLA_MICBIAS1:
2417 cfilt_sel = priv->pdata->micbias.bias1_cfilt_sel;
2418 break;
2419 case TABLA_MICBIAS2:
2420 cfilt_sel = priv->pdata->micbias.bias2_cfilt_sel;
2421 break;
2422 case TABLA_MICBIAS3:
2423 cfilt_sel = priv->pdata->micbias.bias3_cfilt_sel;
2424 break;
2425 default:
2426 pr_err("%s: Error, invalid mic bias line, bias value = %d\n",
2427 __func__, priv->calibration->bias);
2428 return IRQ_HANDLED;
2429 }
2430
2431 switch (cfilt_sel) {
2432 case TABLA_CFILT1_SEL:
2433 micbias_cfilt_ctl_reg = TABLA_A_MICB_CFILT_1_CTL;
2434 break;
2435 case TABLA_CFILT2_SEL:
2436 micbias_cfilt_ctl_reg = TABLA_A_MICB_CFILT_2_CTL;
2437 break;
2438 case TABLA_CFILT3_SEL:
2439 micbias_cfilt_ctl_reg = TABLA_A_MICB_CFILT_3_CTL;
2440 break;
2441 default: /* default should not happen as check should have been done */
2442 pr_err("%s: Invalid cfilt select, cfilt_sel = %d\n",
2443 __func__, cfilt_sel);
2444 return IRQ_HANDLED;
2445 }
2446
2447 ldo_h_on = snd_soc_read(codec, TABLA_A_LDO_H_MODE_1) & 0x80;
2448 micb_cfilt_on = snd_soc_read(codec, micbias_cfilt_ctl_reg) & 0x80;
2449
2450 if (!ldo_h_on)
2451 snd_soc_update_bits(codec, TABLA_A_LDO_H_MODE_1, 0x80, 0x80);
2452 if (!micb_cfilt_on)
2453 snd_soc_update_bits(codec, micbias_cfilt_ctl_reg, 0x80, 0x80);
2454
Bradley Rubincb1e2732011-06-23 16:49:20 -07002455 usleep_range(priv->calibration->setup_plug_removal_delay,
2456 priv->calibration->setup_plug_removal_delay);
2457
2458 if (snd_soc_read(codec, TABLA_A_CDC_MBHC_INT_CTL) & 0x02) {
2459 if (priv->headset_jack) {
2460 pr_debug("%s: Reporting removal\n", __func__);
2461 snd_soc_jack_report(priv->headset_jack, 0,
2462 SND_JACK_HEADSET);
2463 }
2464 tabla_codec_shutdown_hs_removal_detect(codec);
2465 tabla_codec_enable_hs_detect(codec, 1);
2466 return IRQ_HANDLED;
2467 }
2468
Bradley Rubin355611a2011-08-24 14:01:18 -07002469 if (!ldo_h_on)
2470 snd_soc_update_bits(codec, TABLA_A_LDO_H_MODE_1, 0x80, 0x0);
2471 if (!micb_cfilt_on)
2472 snd_soc_update_bits(codec, micbias_cfilt_ctl_reg, 0x80, 0x0);
2473
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002474 mic_voltage = tabla_codec_setup_hs_polling(codec);
Bradley Rubin355611a2011-08-24 14:01:18 -07002475
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002476 if (mic_voltage > threshold_fake_insert) {
2477 pr_debug("%s: Fake insertion interrupt, mic_voltage = %x\n",
2478 __func__, mic_voltage);
2479 tabla_codec_enable_hs_detect(codec, 1);
2480 } else if (mic_voltage < threshold_no_mic) {
2481 pr_debug("%s: Headphone Detected, mic_voltage = %x\n",
2482 __func__, mic_voltage);
2483
Bradley Rubincb1e2732011-06-23 16:49:20 -07002484 if (priv->headset_jack) {
2485 pr_debug("%s: Reporting insertion %d\n", __func__,
2486 SND_JACK_HEADPHONE);
2487 snd_soc_jack_report(priv->headset_jack,
2488 SND_JACK_HEADPHONE, SND_JACK_HEADSET);
2489 }
2490 tabla_codec_shutdown_hs_polling(codec);
2491 tabla_codec_enable_hs_detect(codec, 0);
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002492
2493 } else {
2494 pr_debug("%s: Headset detected, mic_voltage = %x\n",
2495 __func__, mic_voltage);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002496 if (priv->headset_jack) {
2497 pr_debug("%s: Reporting insertion %d\n", __func__,
2498 SND_JACK_HEADSET);
2499 snd_soc_jack_report(priv->headset_jack,
2500 SND_JACK_HEADSET, SND_JACK_HEADSET);
2501 }
2502 tabla_codec_start_hs_polling(codec);
2503 }
2504
2505 return IRQ_HANDLED;
2506}
2507
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002508static irqreturn_t tabla_hs_remove_irq(int irq, void *data)
2509{
2510 struct tabla_priv *priv = data;
2511 struct snd_soc_codec *codec = priv->codec;
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002512 short bias_value;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002513
2514 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
2515 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
Bradley Rubin4d09cf42011-08-17 17:59:16 -07002516 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002517
2518 usleep_range(priv->calibration->shutdown_plug_removal,
2519 priv->calibration->shutdown_plug_removal);
2520
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002521 bias_value = tabla_codec_measure_micbias_voltage(codec, 1);
2522 pr_debug("removal interrupt, bias value is %d\n", bias_value);
2523
2524 if (bias_value < -90) {
2525 pr_debug("False alarm, headset not actually removed\n");
2526 tabla_codec_start_hs_polling(codec);
2527 } else {
2528 if (priv->headset_jack) {
2529 pr_debug("%s: Reporting removal\n", __func__);
2530 snd_soc_jack_report(priv->headset_jack, 0,
2531 SND_JACK_HEADSET);
2532 }
2533 tabla_codec_shutdown_hs_polling(codec);
2534
2535 tabla_codec_enable_hs_detect(codec, 1);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002536 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002537 return IRQ_HANDLED;
2538}
2539
2540static unsigned long slimbus_value;
2541
2542static irqreturn_t tabla_slimbus_irq(int irq, void *data)
2543{
2544 struct tabla_priv *priv = data;
2545 struct snd_soc_codec *codec = priv->codec;
2546 int i, j;
2547 u8 val;
2548
2549 for (i = 0; i < TABLA_SLIM_NUM_PORT_REG; i++) {
2550 slimbus_value = tabla_interface_reg_read(codec->control_data,
2551 TABLA_SLIM_PGD_PORT_INT_STATUS0 + i);
2552 for_each_set_bit(j, &slimbus_value, BITS_PER_BYTE) {
2553 val = tabla_interface_reg_read(codec->control_data,
2554 TABLA_SLIM_PGD_PORT_INT_SOURCE0 + i*8 + j);
2555 if (val & 0x1)
2556 pr_err_ratelimited("overflow error on port %x,"
2557 " value %x\n", i*8 + j, val);
2558 if (val & 0x2)
2559 pr_err_ratelimited("underflow error on port %x,"
2560 " value %x\n", i*8 + j, val);
2561 }
2562 tabla_interface_reg_write(codec->control_data,
2563 TABLA_SLIM_PGD_PORT_INT_CLR0 + i, 0xFF);
2564 }
2565
2566 return IRQ_HANDLED;
2567}
2568
Patrick Lai3043fba2011-08-01 14:15:57 -07002569static int tabla_find_k_value(unsigned int ldoh_v, unsigned int cfilt_mv)
2570{
2571 int rc = -EINVAL;
2572 unsigned min_mv, max_mv;
2573
2574 switch (ldoh_v) {
2575 case TABLA_LDOH_1P95_V:
2576 min_mv = 160;
2577 max_mv = 1800;
2578 break;
2579 case TABLA_LDOH_2P35_V:
2580 min_mv = 200;
2581 max_mv = 2200;
2582 break;
2583 case TABLA_LDOH_2P75_V:
2584 min_mv = 240;
2585 max_mv = 2600;
2586 break;
2587 case TABLA_LDOH_2P85_V:
2588 min_mv = 250;
2589 max_mv = 2700;
2590 break;
2591 default:
2592 goto done;
2593 }
2594
2595 if (cfilt_mv < min_mv || cfilt_mv > max_mv)
2596 goto done;
2597
2598 for (rc = 4; rc <= 44; rc++) {
2599 min_mv = max_mv * (rc) / 44;
2600 if (min_mv >= cfilt_mv) {
2601 rc -= 4;
2602 break;
2603 }
2604 }
2605done:
2606 return rc;
2607}
2608
2609static int tabla_handle_pdata(struct tabla_priv *tabla)
2610{
2611 struct snd_soc_codec *codec = tabla->codec;
2612 struct tabla_pdata *pdata = tabla->pdata;
2613 int k1, k2, k3, rc = 0;
2614
2615 if (!pdata) {
2616 rc = -ENODEV;
2617 goto done;
2618 }
2619
2620 /* Make sure settings are correct */
2621 if ((pdata->micbias.ldoh_v > TABLA_LDOH_2P85_V) ||
2622 (pdata->micbias.bias1_cfilt_sel > TABLA_CFILT3_SEL) ||
2623 (pdata->micbias.bias2_cfilt_sel > TABLA_CFILT3_SEL) ||
2624 (pdata->micbias.bias3_cfilt_sel > TABLA_CFILT3_SEL) ||
2625 (pdata->micbias.bias4_cfilt_sel > TABLA_CFILT3_SEL)) {
2626 rc = -EINVAL;
2627 goto done;
2628 }
2629
2630 /* figure out k value */
2631 k1 = tabla_find_k_value(pdata->micbias.ldoh_v,
2632 pdata->micbias.cfilt1_mv);
2633 k2 = tabla_find_k_value(pdata->micbias.ldoh_v,
2634 pdata->micbias.cfilt2_mv);
2635 k3 = tabla_find_k_value(pdata->micbias.ldoh_v,
2636 pdata->micbias.cfilt3_mv);
2637
2638 if (IS_ERR_VALUE(k1) || IS_ERR_VALUE(k2) || IS_ERR_VALUE(k3)) {
2639 rc = -EINVAL;
2640 goto done;
2641 }
2642
2643 /* Set voltage level and always use LDO */
2644 snd_soc_update_bits(codec, TABLA_A_LDO_H_MODE_1, 0x0C,
2645 (pdata->micbias.ldoh_v << 2));
2646
2647 snd_soc_update_bits(codec, TABLA_A_MICB_CFILT_1_VAL, 0xFC,
2648 (k1 << 2));
2649 snd_soc_update_bits(codec, TABLA_A_MICB_CFILT_2_VAL, 0xFC,
2650 (k2 << 2));
2651 snd_soc_update_bits(codec, TABLA_A_MICB_CFILT_3_VAL, 0xFC,
2652 (k3 << 2));
2653
2654 snd_soc_update_bits(codec, TABLA_A_MICB_1_CTL, 0x60,
2655 (pdata->micbias.bias1_cfilt_sel << 5));
2656 snd_soc_update_bits(codec, TABLA_A_MICB_2_CTL, 0x60,
2657 (pdata->micbias.bias2_cfilt_sel << 5));
2658 snd_soc_update_bits(codec, TABLA_A_MICB_3_CTL, 0x60,
2659 (pdata->micbias.bias3_cfilt_sel << 5));
2660 snd_soc_update_bits(codec, TABLA_A_MICB_4_CTL, 0x60,
2661 (pdata->micbias.bias4_cfilt_sel << 5));
2662
2663done:
2664 return rc;
2665}
2666
Kiran Kandi1f6fd722011-08-11 10:36:11 -07002667static const struct tabla_reg_mask_val tabla_1_1_reg_defaults[] = {
2668
2669 /* Tabla 1.1 MICBIAS changes */
2670 TABLA_REG_VAL(TABLA_A_MICB_1_INT_RBIAS, 0x24),
2671 TABLA_REG_VAL(TABLA_A_MICB_2_INT_RBIAS, 0x24),
2672 TABLA_REG_VAL(TABLA_A_MICB_3_INT_RBIAS, 0x24),
2673 TABLA_REG_VAL(TABLA_A_MICB_4_INT_RBIAS, 0x24),
2674
2675 /* Tabla 1.1 HPH changes */
2676 TABLA_REG_VAL(TABLA_A_RX_HPH_BIAS_PA, 0x57),
2677 TABLA_REG_VAL(TABLA_A_RX_HPH_BIAS_LDO, 0x56),
2678
2679 /* Tabla 1.1 EAR PA changes */
2680 TABLA_REG_VAL(TABLA_A_RX_EAR_BIAS_PA, 0xA6),
2681 TABLA_REG_VAL(TABLA_A_RX_EAR_GAIN, 0x02),
2682 TABLA_REG_VAL(TABLA_A_RX_EAR_VCM, 0x03),
2683
2684 /* Tabla 1.1 Lineout_5 Changes */
2685 TABLA_REG_VAL(TABLA_A_RX_LINE_5_GAIN, 0x10),
2686
2687 /* Tabla 1.1 RX Changes */
2688 TABLA_REG_VAL(TABLA_A_CDC_RX1_B5_CTL, 0x78),
2689 TABLA_REG_VAL(TABLA_A_CDC_RX2_B5_CTL, 0x78),
2690 TABLA_REG_VAL(TABLA_A_CDC_RX3_B5_CTL, 0x78),
2691 TABLA_REG_VAL(TABLA_A_CDC_RX4_B5_CTL, 0x78),
2692 TABLA_REG_VAL(TABLA_A_CDC_RX5_B5_CTL, 0x78),
2693 TABLA_REG_VAL(TABLA_A_CDC_RX6_B5_CTL, 0x78),
2694 TABLA_REG_VAL(TABLA_A_CDC_RX7_B5_CTL, 0x78),
2695
2696 /* Tabla 1.1 RX1 and RX2 Changes */
2697 TABLA_REG_VAL(TABLA_A_CDC_RX1_B6_CTL, 0xA0),
2698 TABLA_REG_VAL(TABLA_A_CDC_RX2_B6_CTL, 0xA0),
2699
2700 /* Tabla 1.1 RX3 to RX7 Changes */
2701 TABLA_REG_VAL(TABLA_A_CDC_RX3_B6_CTL, 0x80),
2702 TABLA_REG_VAL(TABLA_A_CDC_RX4_B6_CTL, 0x80),
2703 TABLA_REG_VAL(TABLA_A_CDC_RX5_B6_CTL, 0x80),
2704 TABLA_REG_VAL(TABLA_A_CDC_RX6_B6_CTL, 0x80),
2705 TABLA_REG_VAL(TABLA_A_CDC_RX7_B6_CTL, 0x80),
2706
2707 /* Tabla 1.1 CLASSG Changes */
2708 TABLA_REG_VAL(TABLA_A_CDC_CLSG_FREQ_THRESH_B3_CTL, 0x1B),
2709};
2710
2711static const struct tabla_reg_mask_val tabla_2_0_reg_defaults[] = {
2712
2713 /* Tabla 2.0 MICBIAS changes */
2714 TABLA_REG_VAL(TABLA_A_MICB_2_MBHC, 0x02),
2715};
2716
2717static void tabla_update_reg_defaults(struct snd_soc_codec *codec)
2718{
2719 u32 i;
2720
2721 for (i = 0; i < ARRAY_SIZE(tabla_1_1_reg_defaults); i++)
2722 snd_soc_write(codec, tabla_1_1_reg_defaults[i].reg,
2723 tabla_1_1_reg_defaults[i].val);
2724
2725 for (i = 0; i < ARRAY_SIZE(tabla_2_0_reg_defaults); i++)
2726 snd_soc_write(codec, tabla_2_0_reg_defaults[i].reg,
2727 tabla_2_0_reg_defaults[i].val);
2728}
2729
2730static const struct tabla_reg_mask_val tabla_codec_reg_init_val[] = {
2731
2732 /* Initialize gain registers to use register gain */
2733 {TABLA_A_RX_HPH_L_GAIN, 0x10, 0x10},
2734 {TABLA_A_RX_HPH_R_GAIN, 0x10, 0x10},
2735 {TABLA_A_RX_LINE_1_GAIN, 0x10, 0x10},
2736 {TABLA_A_RX_LINE_2_GAIN, 0x10, 0x10},
2737 {TABLA_A_RX_LINE_3_GAIN, 0x10, 0x10},
2738 {TABLA_A_RX_LINE_4_GAIN, 0x10, 0x10},
2739
2740 /* Initialize mic biases to differential mode */
2741 {TABLA_A_MICB_1_INT_RBIAS, 0x24, 0x24},
2742 {TABLA_A_MICB_2_INT_RBIAS, 0x24, 0x24},
2743 {TABLA_A_MICB_3_INT_RBIAS, 0x24, 0x24},
2744 {TABLA_A_MICB_4_INT_RBIAS, 0x24, 0x24},
2745
2746 {TABLA_A_CDC_CONN_CLSG_CTL, 0x3C, 0x14},
2747
2748 /* Use 16 bit sample size for TX1 to TX6 */
2749 {TABLA_A_CDC_CONN_TX_SB_B1_CTL, 0x30, 0x20},
2750 {TABLA_A_CDC_CONN_TX_SB_B2_CTL, 0x30, 0x20},
2751 {TABLA_A_CDC_CONN_TX_SB_B3_CTL, 0x30, 0x20},
2752 {TABLA_A_CDC_CONN_TX_SB_B4_CTL, 0x30, 0x20},
2753 {TABLA_A_CDC_CONN_TX_SB_B5_CTL, 0x30, 0x20},
2754 {TABLA_A_CDC_CONN_TX_SB_B6_CTL, 0x30, 0x20},
2755
2756 /* Use 16 bit sample size for TX7 to TX10 */
2757 {TABLA_A_CDC_CONN_TX_SB_B7_CTL, 0x60, 0x40},
2758 {TABLA_A_CDC_CONN_TX_SB_B8_CTL, 0x60, 0x40},
2759 {TABLA_A_CDC_CONN_TX_SB_B9_CTL, 0x60, 0x40},
2760 {TABLA_A_CDC_CONN_TX_SB_B10_CTL, 0x60, 0x40},
2761
2762 /* Use 16 bit sample size for RX */
2763 {TABLA_A_CDC_CONN_RX_SB_B1_CTL, 0xFF, 0xAA},
2764 {TABLA_A_CDC_CONN_RX_SB_B2_CTL, 0xFF, 0xAA},
2765
2766 /*enable HPF filter for TX paths */
2767 {TABLA_A_CDC_TX1_MUX_CTL, 0x8, 0x0},
2768 {TABLA_A_CDC_TX2_MUX_CTL, 0x8, 0x0},
2769 {TABLA_A_CDC_TX3_MUX_CTL, 0x8, 0x0},
2770 {TABLA_A_CDC_TX4_MUX_CTL, 0x8, 0x0},
2771 {TABLA_A_CDC_TX5_MUX_CTL, 0x8, 0x0},
2772 {TABLA_A_CDC_TX6_MUX_CTL, 0x8, 0x0},
2773 {TABLA_A_CDC_TX7_MUX_CTL, 0x8, 0x0},
2774 {TABLA_A_CDC_TX8_MUX_CTL, 0x8, 0x0},
2775 {TABLA_A_CDC_TX9_MUX_CTL, 0x8, 0x0},
2776 {TABLA_A_CDC_TX10_MUX_CTL, 0x8, 0x0},
2777};
2778
2779static void tabla_codec_init_reg(struct snd_soc_codec *codec)
2780{
2781 u32 i;
2782
2783 for (i = 0; i < ARRAY_SIZE(tabla_codec_reg_init_val); i++)
2784 snd_soc_update_bits(codec, tabla_codec_reg_init_val[i].reg,
2785 tabla_codec_reg_init_val[i].mask,
2786 tabla_codec_reg_init_val[i].val);
2787}
2788
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002789static int tabla_codec_probe(struct snd_soc_codec *codec)
2790{
2791 struct tabla *control;
2792 struct tabla_priv *tabla;
2793 struct snd_soc_dapm_context *dapm = &codec->dapm;
2794 int ret = 0;
2795 int i;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002796
2797 codec->control_data = dev_get_drvdata(codec->dev->parent);
2798 control = codec->control_data;
2799
2800 tabla = kzalloc(sizeof(struct tabla_priv), GFP_KERNEL);
2801 if (!tabla) {
2802 dev_err(codec->dev, "Failed to allocate private data\n");
2803 return -ENOMEM;
2804 }
2805
2806 snd_soc_codec_set_drvdata(codec, tabla);
2807
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002808 tabla->mclk_enabled = false;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002809 tabla->bandgap_type = TABLA_BANDGAP_OFF;
2810 tabla->clock_active = false;
2811 tabla->config_mode_active = false;
2812 tabla->mbhc_polling_active = false;
Bradley Rubincb3950a2011-08-18 13:07:26 -07002813 tabla->no_mic_headset_override = false;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002814 tabla->codec = codec;
Patrick Lai3043fba2011-08-01 14:15:57 -07002815 tabla->pdata = dev_get_platdata(codec->dev->parent);
2816
2817 ret = tabla_handle_pdata(tabla);
2818
2819 if (IS_ERR_VALUE(ret)) {
2820 pr_err("%s: bad pdata\n", __func__);
2821 goto err_pdata;
2822 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002823
Kiran Kandi1f6fd722011-08-11 10:36:11 -07002824 tabla_update_reg_defaults(codec);
2825 tabla_codec_init_reg(codec);
2826
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002827 /* TODO only enable bandgap when necessary in order to save power */
2828 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_AUDIO_MODE);
2829 tabla_codec_enable_clock_block(codec, 0);
2830
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002831 snd_soc_add_controls(codec, tabla_snd_controls,
2832 ARRAY_SIZE(tabla_snd_controls));
2833 snd_soc_dapm_new_controls(dapm, tabla_dapm_widgets,
2834 ARRAY_SIZE(tabla_dapm_widgets));
2835 snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
2836 snd_soc_dapm_sync(dapm);
2837
2838 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION,
2839 tabla_hs_insert_irq, "Headset insert detect", tabla);
2840 if (ret) {
2841 pr_err("%s: Failed to request irq %d\n", __func__,
2842 TABLA_IRQ_MBHC_INSERTION);
2843 goto err_insert_irq;
2844 }
2845 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION);
2846
2847 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL,
2848 tabla_hs_remove_irq, "Headset remove detect", tabla);
2849 if (ret) {
2850 pr_err("%s: Failed to request irq %d\n", __func__,
2851 TABLA_IRQ_MBHC_REMOVAL);
2852 goto err_remove_irq;
2853 }
2854 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
2855
2856 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL,
Bradley Rubincb1e2732011-06-23 16:49:20 -07002857 tabla_dce_handler, "DC Estimation detect", tabla);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002858 if (ret) {
2859 pr_err("%s: Failed to request irq %d\n", __func__,
2860 TABLA_IRQ_MBHC_POTENTIAL);
2861 goto err_potential_irq;
2862 }
2863 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
2864
Bradley Rubincb1e2732011-06-23 16:49:20 -07002865 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE,
2866 tabla_release_handler, "Button Release detect", tabla);
2867 if (ret) {
2868 pr_err("%s: Failed to request irq %d\n", __func__,
2869 TABLA_IRQ_MBHC_RELEASE);
2870 goto err_release_irq;
2871 }
Bradley Rubin4d09cf42011-08-17 17:59:16 -07002872 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002873
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002874 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_SLIMBUS,
2875 tabla_slimbus_irq, "SLIMBUS Slave", tabla);
2876 if (ret) {
2877 pr_err("%s: Failed to request irq %d\n", __func__,
2878 TABLA_IRQ_SLIMBUS);
2879 goto err_slimbus_irq;
2880 }
2881
2882 for (i = 0; i < TABLA_SLIM_NUM_PORT_REG; i++)
2883 tabla_interface_reg_write(codec->control_data,
2884 TABLA_SLIM_PGD_PORT_INT_EN0 + i, 0xFF);
2885
Bradley Rubincb3950a2011-08-18 13:07:26 -07002886#ifdef CONFIG_DEBUG_FS
2887 debug_tabla_priv = tabla;
2888#endif
2889
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002890 return ret;
2891
2892err_slimbus_irq:
Bradley Rubincb1e2732011-06-23 16:49:20 -07002893 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE, tabla);
2894err_release_irq:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002895 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL, tabla);
2896err_potential_irq:
2897 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL, tabla);
2898err_remove_irq:
2899 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION, tabla);
2900err_insert_irq:
Patrick Lai3043fba2011-08-01 14:15:57 -07002901err_pdata:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002902 kfree(tabla);
2903 return ret;
2904}
2905static int tabla_codec_remove(struct snd_soc_codec *codec)
2906{
2907 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2908 tabla_free_irq(codec->control_data, TABLA_IRQ_SLIMBUS, tabla);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002909 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE, tabla);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002910 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL, tabla);
2911 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL, tabla);
2912 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION, tabla);
2913 tabla_codec_disable_clock_block(codec);
2914 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_OFF);
2915 kfree(tabla);
2916 return 0;
2917}
2918static struct snd_soc_codec_driver soc_codec_dev_tabla = {
2919 .probe = tabla_codec_probe,
2920 .remove = tabla_codec_remove,
2921 .read = tabla_read,
2922 .write = tabla_write,
2923
2924 .readable_register = tabla_readable,
2925 .volatile_register = tabla_volatile,
2926
2927 .reg_cache_size = TABLA_CACHE_SIZE,
2928 .reg_cache_default = tabla_reg_defaults,
2929 .reg_word_size = 1,
2930};
Bradley Rubincb3950a2011-08-18 13:07:26 -07002931
2932#ifdef CONFIG_DEBUG_FS
2933static struct dentry *debugfs_poke;
2934
2935static int codec_debug_open(struct inode *inode, struct file *file)
2936{
2937 file->private_data = inode->i_private;
2938 return 0;
2939}
2940
2941static ssize_t codec_debug_write(struct file *filp,
2942 const char __user *ubuf, size_t cnt, loff_t *ppos)
2943{
2944 char lbuf[32];
2945 char *buf;
2946 int rc;
2947
2948 if (cnt > sizeof(lbuf) - 1)
2949 return -EINVAL;
2950
2951 rc = copy_from_user(lbuf, ubuf, cnt);
2952 if (rc)
2953 return -EFAULT;
2954
2955 lbuf[cnt] = '\0';
2956 buf = (char *)lbuf;
2957 debug_tabla_priv->no_mic_headset_override = (*strsep(&buf, " ") == '0')
2958 ? false : true;
2959
2960 return rc;
2961}
2962
2963static const struct file_operations codec_debug_ops = {
2964 .open = codec_debug_open,
2965 .write = codec_debug_write,
2966};
2967#endif
2968
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002969static int __devinit tabla_probe(struct platform_device *pdev)
2970{
Bradley Rubincb3950a2011-08-18 13:07:26 -07002971#ifdef CONFIG_DEBUG_FS
2972 debugfs_poke = debugfs_create_file("TRRS",
2973 S_IFREG | S_IRUGO, NULL, (void *) "TRRS", &codec_debug_ops);
2974
2975#endif
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002976 return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_tabla,
2977 tabla_dai, ARRAY_SIZE(tabla_dai));
2978}
2979static int __devexit tabla_remove(struct platform_device *pdev)
2980{
2981 snd_soc_unregister_codec(&pdev->dev);
Bradley Rubincb3950a2011-08-18 13:07:26 -07002982
2983#ifdef CONFIG_DEBUG_FS
2984 debugfs_remove(debugfs_poke);
2985#endif
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002986 return 0;
2987}
2988static struct platform_driver tabla_codec_driver = {
2989 .probe = tabla_probe,
2990 .remove = tabla_remove,
2991 .driver = {
2992 .name = "tabla_codec",
2993 .owner = THIS_MODULE,
2994 },
2995};
2996
2997static int __init tabla_codec_init(void)
2998{
2999 return platform_driver_register(&tabla_codec_driver);
3000}
3001
3002static void __exit tabla_codec_exit(void)
3003{
3004 platform_driver_unregister(&tabla_codec_driver);
3005}
3006
3007module_init(tabla_codec_init);
3008module_exit(tabla_codec_exit);
3009
3010MODULE_DESCRIPTION("Tabla codec driver");
3011MODULE_VERSION("1.0");
3012MODULE_LICENSE("GPL v2");