blob: 4be99b188627fe775ef3d37cb01acec147a39031 [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>
Santosh Mardie15e2302011-11-15 10:39:23 +053017#include <linux/device.h>
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070018#include <linux/printk.h>
19#include <linux/ratelimit.h>
Bradley Rubincb3950a2011-08-18 13:07:26 -070020#include <linux/debugfs.h>
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070021#include <linux/mfd/wcd9310/core.h>
22#include <linux/mfd/wcd9310/registers.h>
Patrick Lai3043fba2011-08-01 14:15:57 -070023#include <linux/mfd/wcd9310/pdata.h>
Santosh Mardie15e2302011-11-15 10:39:23 +053024#include <sound/pcm.h>
25#include <sound/pcm_params.h>
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070026#include <sound/jack.h>
27#include <sound/soc.h>
28#include <sound/soc-dapm.h>
29#include <sound/tlv.h>
30#include <linux/bitops.h>
31#include <linux/delay.h>
32#include "wcd9310.h"
33
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -070034#define WCD9310_RATES (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_16000|\
35 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_48000)
36
37#define NUM_DECIMATORS 10
38#define NUM_INTERPOLATORS 7
39#define BITS_PER_REG 8
40#define TABLA_RX_DAI_ID 1
41#define TABLA_TX_DAI_ID 2
42
Patrick Lai49efeac2011-11-03 11:01:12 -070043#define TABLA_JACK_MASK (SND_JACK_HEADSET | SND_JACK_OC_HPHL | SND_JACK_OC_HPHR)
44
Santosh Mardie15e2302011-11-15 10:39:23 +053045#define TABLA_I2S_MASTER_MODE_MASK 0x08
46
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070047static const DECLARE_TLV_DB_SCALE(digital_gain, 0, 1, 0);
48static const DECLARE_TLV_DB_SCALE(line_gain, 0, 7, 1);
49static const DECLARE_TLV_DB_SCALE(analog_gain, 0, 25, 1);
50
51enum tabla_bandgap_type {
52 TABLA_BANDGAP_OFF = 0,
53 TABLA_BANDGAP_AUDIO_MODE,
54 TABLA_BANDGAP_MBHC_MODE,
55};
56
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -070057struct mbhc_micbias_regs {
58 u16 cfilt_val;
59 u16 cfilt_ctl;
60 u16 mbhc_reg;
61 u16 int_rbias;
62 u16 ctl_reg;
63};
64
Bradley Rubin229c6a52011-07-12 16:18:48 -070065struct tabla_priv {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070066 struct snd_soc_codec *codec;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070067 u32 adc_count;
Patrick Lai3043fba2011-08-01 14:15:57 -070068 u32 cfilt1_cnt;
69 u32 cfilt2_cnt;
70 u32 cfilt3_cnt;
Kiran Kandi6fae8bf2011-08-15 10:36:42 -070071 u32 rx_bias_count;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070072 enum tabla_bandgap_type bandgap_type;
Kiran Kandi6fae8bf2011-08-15 10:36:42 -070073 bool mclk_enabled;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070074 bool clock_active;
75 bool config_mode_active;
76 bool mbhc_polling_active;
Bradley Rubincb1e2732011-06-23 16:49:20 -070077 int buttons_pressed;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070078
79 struct tabla_mbhc_calibration *calibration;
80
Bradley Rubincb1e2732011-06-23 16:49:20 -070081 struct snd_soc_jack *headset_jack;
82 struct snd_soc_jack *button_jack;
Bradley Rubin229c6a52011-07-12 16:18:48 -070083
Patrick Lai3043fba2011-08-01 14:15:57 -070084 struct tabla_pdata *pdata;
Bradley Rubina7096d02011-08-03 18:29:02 -070085 u32 anc_slot;
Bradley Rubincb3950a2011-08-18 13:07:26 -070086
87 bool no_mic_headset_override;
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -070088 /* Delayed work to report long button press */
89 struct delayed_work btn0_dwork;
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -070090
91 struct mbhc_micbias_regs mbhc_bias_regs;
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -070092 u8 cfilt_k_value;
93 bool mbhc_micbias_switched;
Patrick Lai49efeac2011-11-03 11:01:12 -070094
Santosh Mardie15e2302011-11-15 10:39:23 +053095 /*track tabla interface type*/
96 u8 intf_type;
97
Patrick Lai49efeac2011-11-03 11:01:12 -070098 u32 hph_status; /* track headhpone status */
99 /* define separate work for left and right headphone OCP to avoid
100 * additional checking on which OCP event to report so no locking
101 * to ensure synchronization is required
102 */
103 struct work_struct hphlocp_work; /* reporting left hph ocp off */
104 struct work_struct hphrocp_work; /* reporting right hph ocp off */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700105};
106
Bradley Rubincb3950a2011-08-18 13:07:26 -0700107#ifdef CONFIG_DEBUG_FS
108struct tabla_priv *debug_tabla_priv;
109#endif
110
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700111static int tabla_codec_enable_charge_pump(struct snd_soc_dapm_widget *w,
112 struct snd_kcontrol *kcontrol, int event)
113{
114 struct snd_soc_codec *codec = w->codec;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700115
116 pr_debug("%s %d\n", __func__, event);
117 switch (event) {
118 case SND_SOC_DAPM_POST_PMU:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700119 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL, 0x01,
120 0x01);
121 snd_soc_update_bits(codec, TABLA_A_CDC_CLSG_CTL, 0x08, 0x08);
122 usleep_range(200, 200);
123 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x10, 0x00);
124 break;
125 case SND_SOC_DAPM_PRE_PMD:
126 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_RESET_CTL, 0x10,
127 0x10);
128 usleep_range(20, 20);
129 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x08, 0x08);
130 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x10, 0x10);
131 snd_soc_update_bits(codec, TABLA_A_CDC_CLSG_CTL, 0x08, 0x00);
132 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL, 0x01,
133 0x00);
134 snd_soc_update_bits(codec, TABLA_A_CP_STATIC, 0x08, 0x00);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700135 break;
136 }
137 return 0;
138}
139
Bradley Rubina7096d02011-08-03 18:29:02 -0700140static int tabla_get_anc_slot(struct snd_kcontrol *kcontrol,
141 struct snd_ctl_elem_value *ucontrol)
142{
143 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
144 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
145 ucontrol->value.integer.value[0] = tabla->anc_slot;
146 return 0;
147}
148
149static int tabla_put_anc_slot(struct snd_kcontrol *kcontrol,
150 struct snd_ctl_elem_value *ucontrol)
151{
152 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
153 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
154 tabla->anc_slot = ucontrol->value.integer.value[0];
155 return 0;
156}
157
Kiran Kandid2d86b52011-09-09 17:44:28 -0700158static int tabla_pa_gain_get(struct snd_kcontrol *kcontrol,
159 struct snd_ctl_elem_value *ucontrol)
160{
161 u8 ear_pa_gain;
162 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
163
164 ear_pa_gain = snd_soc_read(codec, TABLA_A_RX_EAR_GAIN);
165
166 ear_pa_gain = ear_pa_gain >> 5;
167
168 if (ear_pa_gain == 0x00) {
169 ucontrol->value.integer.value[0] = 0;
170 } else if (ear_pa_gain == 0x04) {
171 ucontrol->value.integer.value[0] = 1;
172 } else {
173 pr_err("%s: ERROR: Unsupported Ear Gain = 0x%x\n",
174 __func__, ear_pa_gain);
175 return -EINVAL;
176 }
177
178 pr_debug("%s: ear_pa_gain = 0x%x\n", __func__, ear_pa_gain);
179
180 return 0;
181}
182
183static int tabla_pa_gain_put(struct snd_kcontrol *kcontrol,
184 struct snd_ctl_elem_value *ucontrol)
185{
186 u8 ear_pa_gain;
187 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
188
189 pr_debug("%s: ucontrol->value.integer.value[0] = %ld\n", __func__,
190 ucontrol->value.integer.value[0]);
191
192 switch (ucontrol->value.integer.value[0]) {
193 case 0:
194 ear_pa_gain = 0x00;
195 break;
196 case 1:
197 ear_pa_gain = 0x80;
198 break;
199 default:
200 return -EINVAL;
201 }
202
203 snd_soc_update_bits(codec, TABLA_A_RX_EAR_GAIN, 0xE0, ear_pa_gain);
204 return 0;
205}
206
207static const char *tabla_ear_pa_gain_text[] = {"POS_6_DB", "POS_2_DB"};
208static const struct soc_enum tabla_ear_pa_gain_enum[] = {
209 SOC_ENUM_SINGLE_EXT(2, tabla_ear_pa_gain_text),
210};
211
Santosh Mardi024010f2011-10-18 06:27:21 +0530212/*cut of frequency for high pass filter*/
213static const char *cf_text[] = {
214 "MIN_3DB_4Hz", "MIN_3DB_75Hz", "MIN_3DB_150Hz"
215};
216
217static const struct soc_enum cf_dec1_enum =
218 SOC_ENUM_SINGLE(TABLA_A_CDC_TX1_MUX_CTL, 4, 3, cf_text);
219
220static const struct soc_enum cf_dec2_enum =
221 SOC_ENUM_SINGLE(TABLA_A_CDC_TX2_MUX_CTL, 4, 3, cf_text);
222
223static const struct soc_enum cf_dec3_enum =
224 SOC_ENUM_SINGLE(TABLA_A_CDC_TX3_MUX_CTL, 4, 3, cf_text);
225
226static const struct soc_enum cf_dec4_enum =
227 SOC_ENUM_SINGLE(TABLA_A_CDC_TX4_MUX_CTL, 4, 3, cf_text);
228
229static const struct soc_enum cf_dec5_enum =
230 SOC_ENUM_SINGLE(TABLA_A_CDC_TX5_MUX_CTL, 4, 3, cf_text);
231
232static const struct soc_enum cf_dec6_enum =
233 SOC_ENUM_SINGLE(TABLA_A_CDC_TX6_MUX_CTL, 4, 3, cf_text);
234
235static const struct soc_enum cf_dec7_enum =
236 SOC_ENUM_SINGLE(TABLA_A_CDC_TX7_MUX_CTL, 4, 3, cf_text);
237
238static const struct soc_enum cf_dec8_enum =
239 SOC_ENUM_SINGLE(TABLA_A_CDC_TX8_MUX_CTL, 4, 3, cf_text);
240
241static const struct soc_enum cf_dec9_enum =
242 SOC_ENUM_SINGLE(TABLA_A_CDC_TX9_MUX_CTL, 4, 3, cf_text);
243
244static const struct soc_enum cf_dec10_enum =
245 SOC_ENUM_SINGLE(TABLA_A_CDC_TX10_MUX_CTL, 4, 3, cf_text);
246
247static const struct soc_enum cf_rxmix1_enum =
248 SOC_ENUM_SINGLE(TABLA_A_CDC_RX1_B4_CTL, 1, 3, cf_text);
249
250static const struct soc_enum cf_rxmix2_enum =
251 SOC_ENUM_SINGLE(TABLA_A_CDC_RX2_B4_CTL, 1, 3, cf_text);
252
253static const struct soc_enum cf_rxmix3_enum =
254 SOC_ENUM_SINGLE(TABLA_A_CDC_RX3_B4_CTL, 1, 3, cf_text);
255
256static const struct soc_enum cf_rxmix4_enum =
257 SOC_ENUM_SINGLE(TABLA_A_CDC_RX4_B4_CTL, 1, 3, cf_text);
258
259static const struct soc_enum cf_rxmix5_enum =
260 SOC_ENUM_SINGLE(TABLA_A_CDC_RX5_B4_CTL, 1, 3, cf_text)
261;
262static const struct soc_enum cf_rxmix6_enum =
263 SOC_ENUM_SINGLE(TABLA_A_CDC_RX6_B4_CTL, 1, 3, cf_text);
264
265static const struct soc_enum cf_rxmix7_enum =
266 SOC_ENUM_SINGLE(TABLA_A_CDC_RX7_B4_CTL, 1, 3, cf_text);
267
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700268static const struct snd_kcontrol_new tabla_snd_controls[] = {
Kiran Kandid2d86b52011-09-09 17:44:28 -0700269
270 SOC_ENUM_EXT("EAR PA Gain", tabla_ear_pa_gain_enum[0],
271 tabla_pa_gain_get, tabla_pa_gain_put),
272
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700273 SOC_SINGLE_TLV("LINEOUT1 Volume", TABLA_A_RX_LINE_1_GAIN, 0, 12, 1,
274 line_gain),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700275 SOC_SINGLE_TLV("LINEOUT2 Volume", TABLA_A_RX_LINE_2_GAIN, 0, 12, 1,
276 line_gain),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700277 SOC_SINGLE_TLV("LINEOUT3 Volume", TABLA_A_RX_LINE_3_GAIN, 0, 12, 1,
278 line_gain),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700279 SOC_SINGLE_TLV("LINEOUT4 Volume", TABLA_A_RX_LINE_4_GAIN, 0, 12, 1,
280 line_gain),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700281 SOC_SINGLE_TLV("LINEOUT5 Volume", TABLA_A_RX_LINE_5_GAIN, 0, 12, 1,
282 line_gain),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700283
284 SOC_SINGLE("RX1 CHAIN INVERT Switch", TABLA_A_CDC_RX1_B6_CTL, 4, 1, 0),
285 SOC_SINGLE("RX2 CHAIN INVERT Switch", TABLA_A_CDC_RX2_B6_CTL, 4, 1, 0),
286 SOC_SINGLE("RX3 CHAIN INVERT Switch", TABLA_A_CDC_RX3_B6_CTL, 4, 1, 0),
287 SOC_SINGLE("RX4 CHAIN INVERT Switch", TABLA_A_CDC_RX4_B6_CTL, 4, 1, 0),
288 SOC_SINGLE("RX5 CHAIN INVERT Switch", TABLA_A_CDC_RX5_B6_CTL, 4, 1, 0),
289 SOC_SINGLE("RX6 CHAIN INVERT Switch", TABLA_A_CDC_RX6_B6_CTL, 4, 1, 0),
290
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700291 SOC_SINGLE_TLV("HPHL Volume", TABLA_A_RX_HPH_L_GAIN, 0, 12, 1,
292 line_gain),
293 SOC_SINGLE_TLV("HPHR Volume", TABLA_A_RX_HPH_R_GAIN, 0, 12, 1,
294 line_gain),
295
Bradley Rubin410383f2011-07-22 13:44:23 -0700296 SOC_SINGLE_S8_TLV("RX1 Digital Volume", TABLA_A_CDC_RX1_VOL_CTL_B2_CTL,
297 -84, 40, digital_gain),
298 SOC_SINGLE_S8_TLV("RX2 Digital Volume", TABLA_A_CDC_RX2_VOL_CTL_B2_CTL,
299 -84, 40, digital_gain),
300 SOC_SINGLE_S8_TLV("RX3 Digital Volume", TABLA_A_CDC_RX3_VOL_CTL_B2_CTL,
301 -84, 40, digital_gain),
302 SOC_SINGLE_S8_TLV("RX4 Digital Volume", TABLA_A_CDC_RX4_VOL_CTL_B2_CTL,
303 -84, 40, digital_gain),
304 SOC_SINGLE_S8_TLV("RX5 Digital Volume", TABLA_A_CDC_RX5_VOL_CTL_B2_CTL,
305 -84, 40, digital_gain),
306 SOC_SINGLE_S8_TLV("RX6 Digital Volume", TABLA_A_CDC_RX6_VOL_CTL_B2_CTL,
307 -84, 40, digital_gain),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700308
Bradley Rubin410383f2011-07-22 13:44:23 -0700309 SOC_SINGLE_S8_TLV("DEC1 Volume", TABLA_A_CDC_TX1_VOL_CTL_GAIN, -84, 40,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700310 digital_gain),
Bradley Rubin410383f2011-07-22 13:44:23 -0700311 SOC_SINGLE_S8_TLV("DEC2 Volume", TABLA_A_CDC_TX2_VOL_CTL_GAIN, -84, 40,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700312 digital_gain),
Bradley Rubin410383f2011-07-22 13:44:23 -0700313 SOC_SINGLE_S8_TLV("DEC3 Volume", TABLA_A_CDC_TX3_VOL_CTL_GAIN, -84, 40,
314 digital_gain),
315 SOC_SINGLE_S8_TLV("DEC4 Volume", TABLA_A_CDC_TX4_VOL_CTL_GAIN, -84, 40,
316 digital_gain),
317 SOC_SINGLE_S8_TLV("DEC5 Volume", TABLA_A_CDC_TX5_VOL_CTL_GAIN, -84, 40,
318 digital_gain),
319 SOC_SINGLE_S8_TLV("DEC6 Volume", TABLA_A_CDC_TX6_VOL_CTL_GAIN, -84, 40,
320 digital_gain),
321 SOC_SINGLE_S8_TLV("DEC7 Volume", TABLA_A_CDC_TX7_VOL_CTL_GAIN, -84, 40,
322 digital_gain),
323 SOC_SINGLE_S8_TLV("DEC8 Volume", TABLA_A_CDC_TX8_VOL_CTL_GAIN, -84, 40,
324 digital_gain),
325 SOC_SINGLE_S8_TLV("DEC9 Volume", TABLA_A_CDC_TX9_VOL_CTL_GAIN, -84, 40,
326 digital_gain),
327 SOC_SINGLE_S8_TLV("DEC10 Volume", TABLA_A_CDC_TX10_VOL_CTL_GAIN, -84,
328 40, digital_gain),
Patrick Lai29006372011-09-28 17:57:42 -0700329 SOC_SINGLE_S8_TLV("IIR1 INP1 Volume", TABLA_A_CDC_IIR1_GAIN_B1_CTL, -84,
330 40, digital_gain),
331 SOC_SINGLE_S8_TLV("IIR1 INP2 Volume", TABLA_A_CDC_IIR1_GAIN_B2_CTL, -84,
332 40, digital_gain),
333 SOC_SINGLE_S8_TLV("IIR1 INP3 Volume", TABLA_A_CDC_IIR1_GAIN_B3_CTL, -84,
334 40, digital_gain),
335 SOC_SINGLE_S8_TLV("IIR1 INP4 Volume", TABLA_A_CDC_IIR1_GAIN_B4_CTL, -84,
336 40, digital_gain),
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700337 SOC_SINGLE_TLV("ADC1 Volume", TABLA_A_TX_1_2_EN, 5, 3, 0, analog_gain),
338 SOC_SINGLE_TLV("ADC2 Volume", TABLA_A_TX_1_2_EN, 1, 3, 0, analog_gain),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700339 SOC_SINGLE_TLV("ADC3 Volume", TABLA_A_TX_3_4_EN, 5, 3, 0, analog_gain),
340 SOC_SINGLE_TLV("ADC4 Volume", TABLA_A_TX_3_4_EN, 1, 3, 0, analog_gain),
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700341 SOC_SINGLE_TLV("ADC5 Volume", TABLA_A_TX_5_6_EN, 5, 3, 0, analog_gain),
342 SOC_SINGLE_TLV("ADC6 Volume", TABLA_A_TX_5_6_EN, 1, 3, 0, analog_gain),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700343
344 SOC_SINGLE("MICBIAS1 CAPLESS Switch", TABLA_A_MICB_1_CTL, 4, 1, 1),
Santosh Mardi680b41e2011-11-22 16:51:16 -0800345 SOC_SINGLE("MICBIAS2 CAPLESS Switch", TABLA_A_MICB_2_CTL, 4, 1, 1),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700346 SOC_SINGLE("MICBIAS3 CAPLESS Switch", TABLA_A_MICB_3_CTL, 4, 1, 1),
347 SOC_SINGLE("MICBIAS4 CAPLESS Switch", TABLA_A_MICB_4_CTL, 4, 1, 1),
Bradley Rubina7096d02011-08-03 18:29:02 -0700348
349 SOC_SINGLE_EXT("ANC Slot", SND_SOC_NOPM, 0, 0, 100, tabla_get_anc_slot,
350 tabla_put_anc_slot),
Santosh Mardi024010f2011-10-18 06:27:21 +0530351 SOC_ENUM("TX1 HPF cut off", cf_dec1_enum),
352 SOC_ENUM("TX2 HPF cut off", cf_dec2_enum),
353 SOC_ENUM("TX3 HPF cut off", cf_dec3_enum),
354 SOC_ENUM("TX4 HPF cut off", cf_dec4_enum),
355 SOC_ENUM("TX5 HPF cut off", cf_dec5_enum),
356 SOC_ENUM("TX6 HPF cut off", cf_dec6_enum),
357 SOC_ENUM("TX7 HPF cut off", cf_dec7_enum),
358 SOC_ENUM("TX8 HPF cut off", cf_dec8_enum),
359 SOC_ENUM("TX9 HPF cut off", cf_dec9_enum),
360 SOC_ENUM("TX10 HPF cut off", cf_dec10_enum),
361
362 SOC_SINGLE("TX1 HPF Switch", TABLA_A_CDC_TX1_MUX_CTL, 3, 1, 0),
363 SOC_SINGLE("TX2 HPF Switch", TABLA_A_CDC_TX2_MUX_CTL, 3, 1, 0),
364 SOC_SINGLE("TX3 HPF Switch", TABLA_A_CDC_TX3_MUX_CTL, 3, 1, 0),
365 SOC_SINGLE("TX4 HPF Switch", TABLA_A_CDC_TX4_MUX_CTL, 3, 1, 0),
366 SOC_SINGLE("TX5 HPF Switch", TABLA_A_CDC_TX5_MUX_CTL, 3, 1, 0),
367 SOC_SINGLE("TX6 HPF Switch", TABLA_A_CDC_TX6_MUX_CTL, 3, 1, 0),
368 SOC_SINGLE("TX7 HPF Switch", TABLA_A_CDC_TX7_MUX_CTL, 3, 1, 0),
369 SOC_SINGLE("TX8 HPF Switch", TABLA_A_CDC_TX8_MUX_CTL, 3, 1, 0),
370 SOC_SINGLE("TX9 HPF Switch", TABLA_A_CDC_TX9_MUX_CTL, 3, 1, 0),
371 SOC_SINGLE("TX10 HPF Switch", TABLA_A_CDC_TX10_MUX_CTL, 3, 1, 0),
372
373 SOC_SINGLE("RX1 HPF Switch", TABLA_A_CDC_RX1_B5_CTL, 2, 1, 0),
374 SOC_SINGLE("RX2 HPF Switch", TABLA_A_CDC_RX2_B5_CTL, 2, 1, 0),
375 SOC_SINGLE("RX3 HPF Switch", TABLA_A_CDC_RX3_B5_CTL, 2, 1, 0),
376 SOC_SINGLE("RX4 HPF Switch", TABLA_A_CDC_RX4_B5_CTL, 2, 1, 0),
377 SOC_SINGLE("RX5 HPF Switch", TABLA_A_CDC_RX5_B5_CTL, 2, 1, 0),
378 SOC_SINGLE("RX6 HPF Switch", TABLA_A_CDC_RX6_B5_CTL, 2, 1, 0),
379 SOC_SINGLE("RX7 HPF Switch", TABLA_A_CDC_RX7_B5_CTL, 2, 1, 0),
380
381 SOC_ENUM("RX1 HPF cut off", cf_rxmix1_enum),
382 SOC_ENUM("RX2 HPF cut off", cf_rxmix2_enum),
383 SOC_ENUM("RX3 HPF cut off", cf_rxmix3_enum),
384 SOC_ENUM("RX4 HPF cut off", cf_rxmix4_enum),
385 SOC_ENUM("RX5 HPF cut off", cf_rxmix5_enum),
386 SOC_ENUM("RX6 HPF cut off", cf_rxmix6_enum),
387 SOC_ENUM("RX7 HPF cut off", cf_rxmix7_enum),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700388};
389
390static const char *rx_mix1_text[] = {
391 "ZERO", "SRC1", "SRC2", "IIR1", "IIR2", "RX1", "RX2", "RX3", "RX4",
392 "RX5", "RX6", "RX7"
393};
394
395static const char *sb_tx1_mux_text[] = {
396 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
397 "DEC1"
398};
399
400static const char *sb_tx5_mux_text[] = {
401 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
402 "DEC5"
403};
404
405static const char *sb_tx6_mux_text[] = {
406 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
407 "DEC6"
408};
409
410static const char const *sb_tx7_to_tx10_mux_text[] = {
411 "ZERO", "RMIX1", "RMIX2", "RMIX3", "RMIX4", "RMIX5", "RMIX6", "RMIX7",
412 "DEC1", "DEC2", "DEC3", "DEC4", "DEC5", "DEC6", "DEC7", "DEC8",
413 "DEC9", "DEC10"
414};
415
416static const char *dec1_mux_text[] = {
417 "ZERO", "DMIC1", "ADC6",
418};
419
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700420static const char *dec2_mux_text[] = {
421 "ZERO", "DMIC2", "ADC5",
422};
423
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700424static const char *dec3_mux_text[] = {
425 "ZERO", "DMIC3", "ADC4",
426};
427
428static const char *dec4_mux_text[] = {
429 "ZERO", "DMIC4", "ADC3",
430};
431
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700432static const char *dec5_mux_text[] = {
433 "ZERO", "DMIC5", "ADC2",
434};
435
436static const char *dec6_mux_text[] = {
437 "ZERO", "DMIC6", "ADC1",
438};
439
440static const char const *dec7_mux_text[] = {
441 "ZERO", "DMIC1", "DMIC6", "ADC1", "ADC6", "ANC1_FB", "ANC2_FB",
442};
443
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700444static const char *dec8_mux_text[] = {
445 "ZERO", "DMIC2", "DMIC5", "ADC2", "ADC5",
446};
447
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700448static const char *dec9_mux_text[] = {
449 "ZERO", "DMIC4", "DMIC5", "ADC2", "ADC3", "ADCMB", "ANC1_FB", "ANC2_FB",
450};
451
452static const char *dec10_mux_text[] = {
453 "ZERO", "DMIC3", "DMIC6", "ADC1", "ADC4", "ADCMB", "ANC1_FB", "ANC2_FB",
454};
455
Bradley Rubin229c6a52011-07-12 16:18:48 -0700456static const char const *anc_mux_text[] = {
457 "ZERO", "ADC1", "ADC2", "ADC3", "ADC4", "ADC5", "ADC6", "ADC_MB",
458 "RSVD_1", "DMIC1", "DMIC2", "DMIC3", "DMIC4", "DMIC5", "DMIC6"
459};
460
461static const char const *anc1_fb_mux_text[] = {
462 "ZERO", "EAR_HPH_L", "EAR_LINE_1",
463};
464
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700465static const char *iir1_inp1_text[] = {
466 "ZERO", "DEC1", "DEC2", "DEC3", "DEC4", "DEC5", "DEC6", "DEC7", "DEC8",
467 "DEC9", "DEC10", "RX1", "RX2", "RX3", "RX4", "RX5", "RX6", "RX7"
468};
469
470static const struct soc_enum rx_mix1_inp1_chain_enum =
471 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX1_B1_CTL, 0, 12, rx_mix1_text);
472
Bradley Rubin229c6a52011-07-12 16:18:48 -0700473static const struct soc_enum rx_mix1_inp2_chain_enum =
474 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX1_B1_CTL, 4, 12, rx_mix1_text);
475
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700476static const struct soc_enum rx2_mix1_inp1_chain_enum =
477 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX2_B1_CTL, 0, 12, rx_mix1_text);
478
Bradley Rubin229c6a52011-07-12 16:18:48 -0700479static const struct soc_enum rx2_mix1_inp2_chain_enum =
480 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX2_B1_CTL, 4, 12, rx_mix1_text);
481
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700482static const struct soc_enum rx3_mix1_inp1_chain_enum =
483 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX3_B1_CTL, 0, 12, rx_mix1_text);
484
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700485static const struct soc_enum rx3_mix1_inp2_chain_enum =
486 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX3_B1_CTL, 4, 12, rx_mix1_text);
487
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700488static const struct soc_enum rx4_mix1_inp1_chain_enum =
489 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX4_B1_CTL, 0, 12, rx_mix1_text);
490
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700491static const struct soc_enum rx4_mix1_inp2_chain_enum =
492 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX4_B1_CTL, 4, 12, rx_mix1_text);
493
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700494static const struct soc_enum rx5_mix1_inp1_chain_enum =
495 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX5_B1_CTL, 0, 12, rx_mix1_text);
496
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700497static const struct soc_enum rx5_mix1_inp2_chain_enum =
498 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX5_B1_CTL, 4, 12, rx_mix1_text);
499
500static const struct soc_enum rx6_mix1_inp1_chain_enum =
501 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX6_B1_CTL, 0, 12, rx_mix1_text);
502
503static const struct soc_enum rx6_mix1_inp2_chain_enum =
504 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX6_B1_CTL, 4, 12, rx_mix1_text);
505
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700506static const struct soc_enum rx7_mix1_inp1_chain_enum =
507 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX7_B1_CTL, 0, 12, rx_mix1_text);
508
509static const struct soc_enum rx7_mix1_inp2_chain_enum =
510 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_RX7_B1_CTL, 4, 12, rx_mix1_text);
511
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700512static const struct soc_enum sb_tx5_mux_enum =
513 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B5_CTL, 0, 9, sb_tx5_mux_text);
514
515static const struct soc_enum sb_tx6_mux_enum =
516 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B6_CTL, 0, 9, sb_tx6_mux_text);
517
518static const struct soc_enum sb_tx7_mux_enum =
519 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B7_CTL, 0, 18,
520 sb_tx7_to_tx10_mux_text);
521
522static const struct soc_enum sb_tx8_mux_enum =
523 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B8_CTL, 0, 18,
524 sb_tx7_to_tx10_mux_text);
525
526static const struct soc_enum sb_tx1_mux_enum =
527 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_SB_B1_CTL, 0, 9, sb_tx1_mux_text);
528
529static const struct soc_enum dec1_mux_enum =
530 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 0, 3, dec1_mux_text);
531
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700532static const struct soc_enum dec2_mux_enum =
533 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 2, 3, dec2_mux_text);
534
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700535static const struct soc_enum dec3_mux_enum =
536 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 4, 3, dec3_mux_text);
537
538static const struct soc_enum dec4_mux_enum =
539 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B1_CTL, 6, 3, dec4_mux_text);
540
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700541static const struct soc_enum dec5_mux_enum =
542 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B2_CTL, 0, 3, dec5_mux_text);
543
544static const struct soc_enum dec6_mux_enum =
545 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B2_CTL, 2, 3, dec6_mux_text);
546
547static const struct soc_enum dec7_mux_enum =
548 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B2_CTL, 4, 7, dec7_mux_text);
549
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700550static const struct soc_enum dec8_mux_enum =
551 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B3_CTL, 0, 7, dec8_mux_text);
552
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700553static const struct soc_enum dec9_mux_enum =
554 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B3_CTL, 3, 8, dec9_mux_text);
555
556static const struct soc_enum dec10_mux_enum =
557 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_TX_B4_CTL, 0, 8, dec10_mux_text);
558
Bradley Rubin229c6a52011-07-12 16:18:48 -0700559static const struct soc_enum anc1_mux_enum =
560 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_ANC_B1_CTL, 0, 16, anc_mux_text);
561
562static const struct soc_enum anc2_mux_enum =
563 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_ANC_B1_CTL, 4, 16, anc_mux_text);
564
565static const struct soc_enum anc1_fb_mux_enum =
566 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_ANC_B2_CTL, 0, 3, anc1_fb_mux_text);
567
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700568static const struct soc_enum iir1_inp1_mux_enum =
569 SOC_ENUM_SINGLE(TABLA_A_CDC_CONN_EQ1_B1_CTL, 0, 18, iir1_inp1_text);
570
571static const struct snd_kcontrol_new rx_mix1_inp1_mux =
572 SOC_DAPM_ENUM("RX1 MIX1 INP1 Mux", rx_mix1_inp1_chain_enum);
573
Bradley Rubin229c6a52011-07-12 16:18:48 -0700574static const struct snd_kcontrol_new rx_mix1_inp2_mux =
575 SOC_DAPM_ENUM("RX1 MIX1 INP2 Mux", rx_mix1_inp2_chain_enum);
576
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700577static const struct snd_kcontrol_new rx2_mix1_inp1_mux =
578 SOC_DAPM_ENUM("RX2 MIX1 INP1 Mux", rx2_mix1_inp1_chain_enum);
579
Bradley Rubin229c6a52011-07-12 16:18:48 -0700580static const struct snd_kcontrol_new rx2_mix1_inp2_mux =
581 SOC_DAPM_ENUM("RX2 MIX1 INP2 Mux", rx2_mix1_inp2_chain_enum);
582
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700583static const struct snd_kcontrol_new rx3_mix1_inp1_mux =
584 SOC_DAPM_ENUM("RX3 MIX1 INP1 Mux", rx3_mix1_inp1_chain_enum);
585
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700586static const struct snd_kcontrol_new rx3_mix1_inp2_mux =
587 SOC_DAPM_ENUM("RX3 MIX1 INP2 Mux", rx3_mix1_inp2_chain_enum);
588
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700589static const struct snd_kcontrol_new rx4_mix1_inp1_mux =
590 SOC_DAPM_ENUM("RX4 MIX1 INP1 Mux", rx4_mix1_inp1_chain_enum);
591
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700592static const struct snd_kcontrol_new rx4_mix1_inp2_mux =
593 SOC_DAPM_ENUM("RX4 MIX1 INP2 Mux", rx4_mix1_inp2_chain_enum);
594
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700595static const struct snd_kcontrol_new rx5_mix1_inp1_mux =
596 SOC_DAPM_ENUM("RX5 MIX1 INP1 Mux", rx5_mix1_inp1_chain_enum);
597
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700598static const struct snd_kcontrol_new rx5_mix1_inp2_mux =
599 SOC_DAPM_ENUM("RX5 MIX1 INP2 Mux", rx5_mix1_inp2_chain_enum);
600
601static const struct snd_kcontrol_new rx6_mix1_inp1_mux =
602 SOC_DAPM_ENUM("RX6 MIX1 INP1 Mux", rx6_mix1_inp1_chain_enum);
603
604static const struct snd_kcontrol_new rx6_mix1_inp2_mux =
605 SOC_DAPM_ENUM("RX6 MIX1 INP2 Mux", rx6_mix1_inp2_chain_enum);
606
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700607static const struct snd_kcontrol_new rx7_mix1_inp1_mux =
608 SOC_DAPM_ENUM("RX7 MIX1 INP1 Mux", rx7_mix1_inp1_chain_enum);
609
610static const struct snd_kcontrol_new rx7_mix1_inp2_mux =
611 SOC_DAPM_ENUM("RX7 MIX1 INP2 Mux", rx7_mix1_inp2_chain_enum);
612
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700613static const struct snd_kcontrol_new sb_tx5_mux =
614 SOC_DAPM_ENUM("SLIM TX5 MUX Mux", sb_tx5_mux_enum);
615
616static const struct snd_kcontrol_new sb_tx6_mux =
617 SOC_DAPM_ENUM("SLIM TX6 MUX Mux", sb_tx6_mux_enum);
618
619static const struct snd_kcontrol_new sb_tx7_mux =
620 SOC_DAPM_ENUM("SLIM TX7 MUX Mux", sb_tx7_mux_enum);
621
622static const struct snd_kcontrol_new sb_tx8_mux =
623 SOC_DAPM_ENUM("SLIM TX8 MUX Mux", sb_tx8_mux_enum);
624
625static const struct snd_kcontrol_new sb_tx1_mux =
626 SOC_DAPM_ENUM("SLIM TX1 MUX Mux", sb_tx1_mux_enum);
627
628static const struct snd_kcontrol_new dec1_mux =
629 SOC_DAPM_ENUM("DEC1 MUX Mux", dec1_mux_enum);
630
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700631static const struct snd_kcontrol_new dec2_mux =
632 SOC_DAPM_ENUM("DEC2 MUX Mux", dec2_mux_enum);
633
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700634static const struct snd_kcontrol_new dec3_mux =
635 SOC_DAPM_ENUM("DEC3 MUX Mux", dec3_mux_enum);
636
637static const struct snd_kcontrol_new dec4_mux =
638 SOC_DAPM_ENUM("DEC4 MUX Mux", dec4_mux_enum);
639
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700640static const struct snd_kcontrol_new dec5_mux =
641 SOC_DAPM_ENUM("DEC5 MUX Mux", dec5_mux_enum);
642
643static const struct snd_kcontrol_new dec6_mux =
644 SOC_DAPM_ENUM("DEC6 MUX Mux", dec6_mux_enum);
645
646static const struct snd_kcontrol_new dec7_mux =
647 SOC_DAPM_ENUM("DEC7 MUX Mux", dec7_mux_enum);
648
Bradley Rubin229c6a52011-07-12 16:18:48 -0700649static const struct snd_kcontrol_new anc1_mux =
650 SOC_DAPM_ENUM("ANC1 MUX Mux", anc1_mux_enum);
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -0700651static const struct snd_kcontrol_new dec8_mux =
652 SOC_DAPM_ENUM("DEC8 MUX Mux", dec8_mux_enum);
653
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -0700654static const struct snd_kcontrol_new dec9_mux =
655 SOC_DAPM_ENUM("DEC9 MUX Mux", dec9_mux_enum);
656
657static const struct snd_kcontrol_new dec10_mux =
658 SOC_DAPM_ENUM("DEC10 MUX Mux", dec10_mux_enum);
659
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700660static const struct snd_kcontrol_new iir1_inp1_mux =
661 SOC_DAPM_ENUM("IIR1 INP1 Mux", iir1_inp1_mux_enum);
662
Bradley Rubin229c6a52011-07-12 16:18:48 -0700663static const struct snd_kcontrol_new anc2_mux =
664 SOC_DAPM_ENUM("ANC2 MUX Mux", anc2_mux_enum);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700665
Bradley Rubin229c6a52011-07-12 16:18:48 -0700666static const struct snd_kcontrol_new anc1_fb_mux =
667 SOC_DAPM_ENUM("ANC1 FB MUX Mux", anc1_fb_mux_enum);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700668
Bradley Rubin229c6a52011-07-12 16:18:48 -0700669static const struct snd_kcontrol_new dac1_switch[] = {
670 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_EAR_EN, 5, 1, 0)
671};
672static const struct snd_kcontrol_new hphl_switch[] = {
673 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_HPH_L_DAC_CTL, 6, 1, 0)
674};
675static const struct snd_kcontrol_new hphr_switch[] = {
676 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_HPH_R_DAC_CTL, 6, 1, 0)
677};
678static const struct snd_kcontrol_new lineout1_switch[] = {
679 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_1_DAC_CTL, 6, 1, 0)
680};
681static const struct snd_kcontrol_new lineout2_switch[] = {
682 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_2_DAC_CTL, 6, 1, 0)
683};
684static const struct snd_kcontrol_new lineout3_switch[] = {
685 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_3_DAC_CTL, 6, 1, 0)
686};
687static const struct snd_kcontrol_new lineout4_switch[] = {
688 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_4_DAC_CTL, 6, 1, 0)
689};
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -0700690static const struct snd_kcontrol_new lineout5_switch[] = {
691 SOC_DAPM_SINGLE("Switch", TABLA_A_RX_LINE_5_DAC_CTL, 6, 1, 0)
692};
Bradley Rubin74a9b4a2011-06-13 15:03:43 -0700693
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700694static void tabla_codec_enable_adc_block(struct snd_soc_codec *codec,
695 int enable)
696{
697 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
698
699 pr_debug("%s %d\n", __func__, enable);
700
701 if (enable) {
702 tabla->adc_count++;
703 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS, 0xE0, 0xE0);
704 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL, 0x2, 0x2);
705 } else {
706 tabla->adc_count--;
707 if (!tabla->adc_count) {
708 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_OTHR_CTL,
709 0x2, 0x0);
710 if (!tabla->mbhc_polling_active)
711 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS,
712 0xE0, 0x0);
713 }
714 }
715}
716
717static int tabla_codec_enable_adc(struct snd_soc_dapm_widget *w,
718 struct snd_kcontrol *kcontrol, int event)
719{
720 struct snd_soc_codec *codec = w->codec;
721 u16 adc_reg;
722
723 pr_debug("%s %d\n", __func__, event);
724
725 if (w->reg == TABLA_A_TX_1_2_EN)
726 adc_reg = TABLA_A_TX_1_2_TEST_CTL;
727 else if (w->reg == TABLA_A_TX_3_4_EN)
728 adc_reg = TABLA_A_TX_3_4_TEST_CTL;
729 else if (w->reg == TABLA_A_TX_5_6_EN)
730 adc_reg = TABLA_A_TX_5_6_TEST_CTL;
731 else {
732 pr_err("%s: Error, invalid adc register\n", __func__);
733 return -EINVAL;
734 }
735
736 switch (event) {
737 case SND_SOC_DAPM_PRE_PMU:
738 tabla_codec_enable_adc_block(codec, 1);
739 break;
740 case SND_SOC_DAPM_POST_PMU:
741 snd_soc_update_bits(codec, adc_reg, 1 << w->shift,
742 1 << w->shift);
743 usleep_range(1000, 1000);
744 snd_soc_update_bits(codec, adc_reg, 1 << w->shift, 0x00);
745 usleep_range(1000, 1000);
746 break;
747 case SND_SOC_DAPM_POST_PMD:
748 tabla_codec_enable_adc_block(codec, 0);
749 break;
750 }
751 return 0;
752}
753
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700754static int tabla_codec_enable_lineout(struct snd_soc_dapm_widget *w,
755 struct snd_kcontrol *kcontrol, int event)
756{
757 struct snd_soc_codec *codec = w->codec;
758 u16 lineout_gain_reg;
759
Kiran Kandidb0a4b02011-08-23 09:32:09 -0700760 pr_debug("%s %d %s\n", __func__, event, w->name);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700761
762 switch (w->shift) {
763 case 0:
764 lineout_gain_reg = TABLA_A_RX_LINE_1_GAIN;
765 break;
766 case 1:
767 lineout_gain_reg = TABLA_A_RX_LINE_2_GAIN;
768 break;
769 case 2:
770 lineout_gain_reg = TABLA_A_RX_LINE_3_GAIN;
771 break;
772 case 3:
773 lineout_gain_reg = TABLA_A_RX_LINE_4_GAIN;
774 break;
775 case 4:
776 lineout_gain_reg = TABLA_A_RX_LINE_5_GAIN;
777 break;
778 default:
779 pr_err("%s: Error, incorrect lineout register value\n",
780 __func__);
781 return -EINVAL;
782 }
783
784 switch (event) {
785 case SND_SOC_DAPM_PRE_PMU:
786 snd_soc_update_bits(codec, lineout_gain_reg, 0x40, 0x40);
787 break;
788 case SND_SOC_DAPM_POST_PMU:
Kiran Kandidb0a4b02011-08-23 09:32:09 -0700789 pr_debug("%s: sleeping 40 ms after %s PA turn on\n",
790 __func__, w->name);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700791 usleep_range(40000, 40000);
792 break;
793 case SND_SOC_DAPM_POST_PMD:
794 snd_soc_update_bits(codec, lineout_gain_reg, 0x40, 0x00);
795 break;
796 }
797 return 0;
798}
799
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700800
801static int tabla_codec_enable_dmic(struct snd_soc_dapm_widget *w,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700802 struct snd_kcontrol *kcontrol, int event)
803{
804 struct snd_soc_codec *codec = w->codec;
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700805 u16 tx_mux_ctl_reg, tx_dmic_ctl_reg;
806 u8 dmic_clk_sel, dmic_clk_en;
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -0700807 unsigned int dmic;
808 int ret;
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700809
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -0700810 ret = kstrtouint(strpbrk(w->name, "123456"), 10, &dmic);
811 if (ret < 0) {
812 pr_err("%s: Invalid DMIC line on the codec\n", __func__);
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700813 return -EINVAL;
814 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700815
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -0700816 switch (dmic) {
817 case 1:
818 case 2:
819 dmic_clk_sel = 0x02;
820 dmic_clk_en = 0x01;
821 break;
822
823 case 3:
824 case 4:
825 dmic_clk_sel = 0x08;
826 dmic_clk_en = 0x04;
827 break;
828
829 case 5:
830 case 6:
831 dmic_clk_sel = 0x20;
832 dmic_clk_en = 0x10;
833 break;
834
835 default:
836 pr_err("%s: Invalid DMIC Selection\n", __func__);
837 return -EINVAL;
838 }
839
840 tx_mux_ctl_reg = TABLA_A_CDC_TX1_MUX_CTL + 8 * (dmic - 1);
841 tx_dmic_ctl_reg = TABLA_A_CDC_TX1_DMIC_CTL + 8 * (dmic - 1);
842
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700843 pr_debug("%s %d\n", __func__, event);
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700844
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700845 switch (event) {
846 case SND_SOC_DAPM_PRE_PMU:
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700847 snd_soc_update_bits(codec, tx_mux_ctl_reg, 0x1, 0x1);
848
849 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_DMIC_CTL,
850 dmic_clk_sel, dmic_clk_sel);
851
852 snd_soc_update_bits(codec, tx_dmic_ctl_reg, 0x1, 0x1);
853
854 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_DMIC_CTL,
855 dmic_clk_en, dmic_clk_en);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700856 break;
857 case SND_SOC_DAPM_POST_PMD:
Kiran Kandicf45f6a2011-07-17 21:10:19 -0700858 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_DMIC_CTL,
859 dmic_clk_en, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700860 break;
861 }
862 return 0;
863}
864
Bradley Rubin229c6a52011-07-12 16:18:48 -0700865static int tabla_codec_enable_anc(struct snd_soc_dapm_widget *w,
866 struct snd_kcontrol *kcontrol, int event)
867{
868 struct snd_soc_codec *codec = w->codec;
869 const char *filename;
870 const struct firmware *fw;
871 int i;
872 int ret;
Bradley Rubina7096d02011-08-03 18:29:02 -0700873 int num_anc_slots;
874 struct anc_header *anc_head;
Bradley Rubin229c6a52011-07-12 16:18:48 -0700875 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
Bradley Rubina7096d02011-08-03 18:29:02 -0700876 u32 anc_writes_size = 0;
877 int anc_size_remaining;
878 u32 *anc_ptr;
Bradley Rubin229c6a52011-07-12 16:18:48 -0700879 u16 reg;
880 u8 mask, val, old_val;
881
882 pr_debug("%s %d\n", __func__, event);
883 switch (event) {
884 case SND_SOC_DAPM_PRE_PMU:
885
Bradley Rubin4283a4c2011-07-29 16:18:54 -0700886 filename = "wcd9310/wcd9310_anc.bin";
Bradley Rubin229c6a52011-07-12 16:18:48 -0700887
888 ret = request_firmware(&fw, filename, codec->dev);
889 if (ret != 0) {
890 dev_err(codec->dev, "Failed to acquire ANC data: %d\n",
891 ret);
892 return -ENODEV;
893 }
894
Bradley Rubina7096d02011-08-03 18:29:02 -0700895 if (fw->size < sizeof(struct anc_header)) {
Bradley Rubin229c6a52011-07-12 16:18:48 -0700896 dev_err(codec->dev, "Not enough data\n");
897 release_firmware(fw);
898 return -ENOMEM;
899 }
900
901 /* First number is the number of register writes */
Bradley Rubina7096d02011-08-03 18:29:02 -0700902 anc_head = (struct anc_header *)(fw->data);
903 anc_ptr = (u32 *)((u32)fw->data + sizeof(struct anc_header));
904 anc_size_remaining = fw->size - sizeof(struct anc_header);
905 num_anc_slots = anc_head->num_anc_slots;
Bradley Rubin229c6a52011-07-12 16:18:48 -0700906
Bradley Rubina7096d02011-08-03 18:29:02 -0700907 if (tabla->anc_slot >= num_anc_slots) {
908 dev_err(codec->dev, "Invalid ANC slot selected\n");
909 release_firmware(fw);
910 return -EINVAL;
911 }
912
913 for (i = 0; i < num_anc_slots; i++) {
914
915 if (anc_size_remaining < TABLA_PACKED_REG_SIZE) {
916 dev_err(codec->dev, "Invalid register format\n");
917 release_firmware(fw);
918 return -EINVAL;
919 }
920 anc_writes_size = (u32)(*anc_ptr);
921 anc_size_remaining -= sizeof(u32);
922 anc_ptr += 1;
923
924 if (anc_writes_size * TABLA_PACKED_REG_SIZE
925 > anc_size_remaining) {
926 dev_err(codec->dev, "Invalid register format\n");
927 release_firmware(fw);
928 return -ENOMEM;
929 }
930
931 if (tabla->anc_slot == i)
932 break;
933
934 anc_size_remaining -= (anc_writes_size *
935 TABLA_PACKED_REG_SIZE);
Bradley Rubin939ff3f2011-08-26 17:19:34 -0700936 anc_ptr += anc_writes_size;
Bradley Rubina7096d02011-08-03 18:29:02 -0700937 }
938 if (i == num_anc_slots) {
939 dev_err(codec->dev, "Selected ANC slot not present\n");
Bradley Rubin229c6a52011-07-12 16:18:48 -0700940 release_firmware(fw);
941 return -ENOMEM;
942 }
943
Bradley Rubina7096d02011-08-03 18:29:02 -0700944 for (i = 0; i < anc_writes_size; i++) {
945 TABLA_CODEC_UNPACK_ENTRY(anc_ptr[i], reg,
Bradley Rubin229c6a52011-07-12 16:18:48 -0700946 mask, val);
947 old_val = snd_soc_read(codec, reg);
Bradley Rubin4283a4c2011-07-29 16:18:54 -0700948 snd_soc_write(codec, reg, (old_val & ~mask) |
949 (val & mask));
Bradley Rubin229c6a52011-07-12 16:18:48 -0700950 }
951 release_firmware(fw);
Bradley Rubin229c6a52011-07-12 16:18:48 -0700952
953 break;
954 case SND_SOC_DAPM_POST_PMD:
955 snd_soc_write(codec, TABLA_A_CDC_CLK_ANC_RESET_CTL, 0xFF);
956 snd_soc_write(codec, TABLA_A_CDC_CLK_ANC_CLK_EN_CTL, 0);
957 break;
958 }
959 return 0;
960}
961
Patrick Lai3043fba2011-08-01 14:15:57 -0700962static void tabla_codec_update_cfilt_usage(struct snd_soc_codec *codec,
963 u8 cfilt_sel, int inc)
964{
965 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
966 u32 *cfilt_cnt_ptr = NULL;
967 u16 micb_cfilt_reg;
968
969 switch (cfilt_sel) {
970 case TABLA_CFILT1_SEL:
971 cfilt_cnt_ptr = &tabla->cfilt1_cnt;
972 micb_cfilt_reg = TABLA_A_MICB_CFILT_1_CTL;
973 break;
974 case TABLA_CFILT2_SEL:
975 cfilt_cnt_ptr = &tabla->cfilt2_cnt;
976 micb_cfilt_reg = TABLA_A_MICB_CFILT_2_CTL;
977 break;
978 case TABLA_CFILT3_SEL:
979 cfilt_cnt_ptr = &tabla->cfilt3_cnt;
980 micb_cfilt_reg = TABLA_A_MICB_CFILT_3_CTL;
981 break;
982 default:
983 return; /* should not happen */
984 }
985
986 if (inc) {
987 if (!(*cfilt_cnt_ptr)++)
988 snd_soc_update_bits(codec, micb_cfilt_reg, 0x80, 0x80);
989 } else {
990 /* check if count not zero, decrement
991 * then check if zero, go ahead disable cfilter
992 */
993 if ((*cfilt_cnt_ptr) && !--(*cfilt_cnt_ptr))
994 snd_soc_update_bits(codec, micb_cfilt_reg, 0x80, 0);
995 }
996}
Bradley Rubin229c6a52011-07-12 16:18:48 -0700997
Bradley Rubincb3950a2011-08-18 13:07:26 -0700998static void tabla_codec_disable_button_presses(struct snd_soc_codec *codec)
999{
1000 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B4_CTL, 0x80);
1001 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B3_CTL, 0x00);
1002}
1003
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001004static void tabla_codec_start_hs_polling(struct snd_soc_codec *codec)
1005{
Bradley Rubincb3950a2011-08-18 13:07:26 -07001006 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1007
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001008 snd_soc_write(codec, TABLA_A_MBHC_SCALING_MUX_1, 0x84);
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001009 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
Bradley Rubincb3950a2011-08-18 13:07:26 -07001010 if (!tabla->no_mic_headset_override) {
1011 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
1012 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
1013 } else {
1014 tabla_codec_disable_button_presses(codec);
1015 }
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001016 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x1);
1017 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x0);
1018 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x1);
1019}
1020
1021static void tabla_codec_pause_hs_polling(struct snd_soc_codec *codec)
1022{
Bradley Rubincb3950a2011-08-18 13:07:26 -07001023 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1024
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001025 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
1026 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
Bradley Rubincb3950a2011-08-18 13:07:26 -07001027 if (!tabla->no_mic_headset_override) {
1028 tabla_disable_irq(codec->control_data,
1029 TABLA_IRQ_MBHC_POTENTIAL);
1030 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
1031 }
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001032}
1033
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001034static int tabla_find_k_value(unsigned int ldoh_v, unsigned int cfilt_mv)
1035{
1036 int rc = -EINVAL;
1037 unsigned min_mv, max_mv;
1038
1039 switch (ldoh_v) {
1040 case TABLA_LDOH_1P95_V:
1041 min_mv = 160;
1042 max_mv = 1800;
1043 break;
1044 case TABLA_LDOH_2P35_V:
1045 min_mv = 200;
1046 max_mv = 2200;
1047 break;
1048 case TABLA_LDOH_2P75_V:
1049 min_mv = 240;
1050 max_mv = 2600;
1051 break;
1052 case TABLA_LDOH_2P85_V:
1053 min_mv = 250;
1054 max_mv = 2700;
1055 break;
1056 default:
1057 goto done;
1058 }
1059
1060 if (cfilt_mv < min_mv || cfilt_mv > max_mv)
1061 goto done;
1062
1063 for (rc = 4; rc <= 44; rc++) {
1064 min_mv = max_mv * (rc) / 44;
1065 if (min_mv >= cfilt_mv) {
1066 rc -= 4;
1067 break;
1068 }
1069 }
1070done:
1071 return rc;
1072}
1073
1074static bool tabla_is_hph_pa_on(struct snd_soc_codec *codec)
1075{
1076 u8 hph_reg_val = 0;
1077 hph_reg_val = snd_soc_read(codec, TABLA_A_RX_HPH_CNP_EN);
1078
1079 return (hph_reg_val & 0x30) ? true : false;
1080}
1081
1082static void tabla_codec_switch_micbias(struct snd_soc_codec *codec,
1083 int vddio_switch)
1084{
1085 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1086 int cfilt_k_val;
1087
1088 switch (vddio_switch) {
1089 case 1:
1090 if (tabla->mbhc_polling_active) {
1091 /* Enable Mic Bias switch to VDDIO */
1092 tabla->cfilt_k_value = snd_soc_read(codec,
1093 tabla->mbhc_bias_regs.cfilt_val);
1094 cfilt_k_val = tabla_find_k_value(
1095 tabla->pdata->micbias.ldoh_v, 1800);
1096 snd_soc_update_bits(codec,
1097 tabla->mbhc_bias_regs.cfilt_val,
1098 0xFC, (cfilt_k_val << 2));
1099
1100 snd_soc_update_bits(codec,
1101 tabla->mbhc_bias_regs.mbhc_reg, 0x80, 0x80);
1102 snd_soc_update_bits(codec,
1103 tabla->mbhc_bias_regs.mbhc_reg, 0x10, 0x00);
1104
1105 tabla->mbhc_micbias_switched = true;
1106 pr_debug("%s: Enabled MBHC Mic bias to VDDIO Switch\n",
1107 __func__);
1108 }
1109 break;
1110
1111 case 0:
1112 if (tabla->mbhc_micbias_switched) {
1113 /* Disable Mic Bias switch to VDDIO */
1114 if (tabla->cfilt_k_value != 0)
1115 snd_soc_update_bits(codec,
1116 tabla->mbhc_bias_regs.cfilt_val, 0XFC,
1117 tabla->cfilt_k_value);
1118 snd_soc_update_bits(codec,
1119 tabla->mbhc_bias_regs.mbhc_reg, 0x80, 0x00);
1120 snd_soc_update_bits(codec,
1121 tabla->mbhc_bias_regs.mbhc_reg, 0x10, 0x00);
1122
1123 tabla->mbhc_micbias_switched = false;
1124 pr_debug("%s: Disabled MBHC Mic bias to VDDIO Switch\n",
1125 __func__);
1126 }
1127 break;
1128 }
1129}
1130
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001131static int tabla_codec_enable_micbias(struct snd_soc_dapm_widget *w,
1132 struct snd_kcontrol *kcontrol, int event)
1133{
1134 struct snd_soc_codec *codec = w->codec;
Patrick Lai3043fba2011-08-01 14:15:57 -07001135 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1136 u16 micb_int_reg;
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001137 int micb_line;
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001138 u8 cfilt_sel_val = 0;
Bradley Rubin229c6a52011-07-12 16:18:48 -07001139 char *internal1_text = "Internal1";
1140 char *internal2_text = "Internal2";
1141 char *internal3_text = "Internal3";
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001142
1143 pr_debug("%s %d\n", __func__, event);
1144 switch (w->reg) {
1145 case TABLA_A_MICB_1_CTL:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001146 micb_int_reg = TABLA_A_MICB_1_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -07001147 cfilt_sel_val = tabla->pdata->micbias.bias1_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001148 micb_line = TABLA_MICBIAS1;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001149 break;
1150 case TABLA_A_MICB_2_CTL:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001151 micb_int_reg = TABLA_A_MICB_2_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -07001152 cfilt_sel_val = tabla->pdata->micbias.bias2_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001153 micb_line = TABLA_MICBIAS2;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001154 break;
1155 case TABLA_A_MICB_3_CTL:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001156 micb_int_reg = TABLA_A_MICB_3_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -07001157 cfilt_sel_val = tabla->pdata->micbias.bias3_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001158 micb_line = TABLA_MICBIAS3;
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001159 break;
1160 case TABLA_A_MICB_4_CTL:
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001161 micb_int_reg = TABLA_A_MICB_4_INT_RBIAS;
Patrick Lai3043fba2011-08-01 14:15:57 -07001162 cfilt_sel_val = tabla->pdata->micbias.bias4_cfilt_sel;
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001163 micb_line = TABLA_MICBIAS4;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001164 break;
1165 default:
1166 pr_err("%s: Error, invalid micbias register\n", __func__);
1167 return -EINVAL;
1168 }
1169
1170 switch (event) {
1171 case SND_SOC_DAPM_PRE_PMU:
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001172 /* Decide whether to switch the micbias for MBHC */
1173 if ((w->reg == tabla->mbhc_bias_regs.ctl_reg)
1174 && tabla->mbhc_micbias_switched)
1175 tabla_codec_switch_micbias(codec, 0);
1176
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001177 snd_soc_update_bits(codec, w->reg, 0x0E, 0x0A);
Patrick Lai3043fba2011-08-01 14:15:57 -07001178 tabla_codec_update_cfilt_usage(codec, cfilt_sel_val, 1);
Bradley Rubin229c6a52011-07-12 16:18:48 -07001179
1180 if (strnstr(w->name, internal1_text, 30))
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001181 snd_soc_update_bits(codec, micb_int_reg, 0xE0, 0xE0);
Bradley Rubin229c6a52011-07-12 16:18:48 -07001182 else if (strnstr(w->name, internal2_text, 30))
1183 snd_soc_update_bits(codec, micb_int_reg, 0x1C, 0x1C);
1184 else if (strnstr(w->name, internal3_text, 30))
1185 snd_soc_update_bits(codec, micb_int_reg, 0x3, 0x3);
1186
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001187 break;
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001188 case SND_SOC_DAPM_POST_PMU:
1189 if (tabla->mbhc_polling_active &&
1190 (tabla->calibration->bias == micb_line)) {
1191 tabla_codec_pause_hs_polling(codec);
1192 tabla_codec_start_hs_polling(codec);
1193 }
1194 break;
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001195
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001196 case SND_SOC_DAPM_POST_PMD:
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001197
1198 if ((w->reg == tabla->mbhc_bias_regs.ctl_reg)
1199 && tabla_is_hph_pa_on(codec))
1200 tabla_codec_switch_micbias(codec, 1);
1201
Bradley Rubin229c6a52011-07-12 16:18:48 -07001202 if (strnstr(w->name, internal1_text, 30))
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001203 snd_soc_update_bits(codec, micb_int_reg, 0x80, 0x00);
Bradley Rubin229c6a52011-07-12 16:18:48 -07001204 else if (strnstr(w->name, internal2_text, 30))
1205 snd_soc_update_bits(codec, micb_int_reg, 0x10, 0x00);
1206 else if (strnstr(w->name, internal3_text, 30))
1207 snd_soc_update_bits(codec, micb_int_reg, 0x2, 0x0);
1208
Patrick Lai3043fba2011-08-01 14:15:57 -07001209 tabla_codec_update_cfilt_usage(codec, cfilt_sel_val, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001210 break;
1211 }
1212
1213 return 0;
1214}
1215
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001216static int tabla_codec_enable_dec(struct snd_soc_dapm_widget *w,
1217 struct snd_kcontrol *kcontrol, int event)
1218{
1219 struct snd_soc_codec *codec = w->codec;
1220 u16 dec_reset_reg;
1221
1222 pr_debug("%s %d\n", __func__, event);
1223
1224 if (w->reg == TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL)
1225 dec_reset_reg = TABLA_A_CDC_CLK_TX_RESET_B1_CTL;
1226 else if (w->reg == TABLA_A_CDC_CLK_TX_CLK_EN_B2_CTL)
1227 dec_reset_reg = TABLA_A_CDC_CLK_TX_RESET_B2_CTL;
1228 else {
1229 pr_err("%s: Error, incorrect dec\n", __func__);
1230 return -EINVAL;
1231 }
1232
1233 switch (event) {
1234 case SND_SOC_DAPM_PRE_PMU:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001235 snd_soc_update_bits(codec, dec_reset_reg, 1 << w->shift,
1236 1 << w->shift);
1237 snd_soc_update_bits(codec, dec_reset_reg, 1 << w->shift, 0x0);
1238 break;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001239 }
1240 return 0;
1241}
1242
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001243static int tabla_codec_reset_interpolator(struct snd_soc_dapm_widget *w,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001244 struct snd_kcontrol *kcontrol, int event)
1245{
1246 struct snd_soc_codec *codec = w->codec;
1247
1248 switch (event) {
1249 case SND_SOC_DAPM_PRE_PMU:
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001250 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_RX_RESET_CTL,
1251 1 << w->shift, 1 << w->shift);
1252 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_RX_RESET_CTL,
1253 1 << w->shift, 0x0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001254 break;
1255 }
1256 return 0;
1257}
1258
Bradley Rubin229c6a52011-07-12 16:18:48 -07001259static int tabla_codec_enable_ldo_h(struct snd_soc_dapm_widget *w,
1260 struct snd_kcontrol *kcontrol, int event)
1261{
1262 switch (event) {
1263 case SND_SOC_DAPM_POST_PMU:
1264 case SND_SOC_DAPM_POST_PMD:
1265 usleep_range(1000, 1000);
1266 break;
1267 }
1268 return 0;
1269}
1270
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001271
1272static void tabla_enable_rx_bias(struct snd_soc_codec *codec, u32 enable)
1273{
1274 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1275
1276 if (enable) {
1277 tabla->rx_bias_count++;
1278 if (tabla->rx_bias_count == 1)
1279 snd_soc_update_bits(codec, TABLA_A_RX_COM_BIAS,
1280 0x80, 0x80);
1281 } else {
1282 tabla->rx_bias_count--;
1283 if (!tabla->rx_bias_count)
1284 snd_soc_update_bits(codec, TABLA_A_RX_COM_BIAS,
1285 0x80, 0x00);
1286 }
1287}
1288
1289static int tabla_codec_enable_rx_bias(struct snd_soc_dapm_widget *w,
1290 struct snd_kcontrol *kcontrol, int event)
1291{
1292 struct snd_soc_codec *codec = w->codec;
1293
1294 pr_debug("%s %d\n", __func__, event);
1295
1296 switch (event) {
1297 case SND_SOC_DAPM_PRE_PMU:
1298 tabla_enable_rx_bias(codec, 1);
1299 break;
1300 case SND_SOC_DAPM_POST_PMD:
1301 tabla_enable_rx_bias(codec, 0);
1302 break;
1303 }
1304 return 0;
1305}
1306
Patrick Lai49efeac2011-11-03 11:01:12 -07001307static void hphocp_off_report(struct tabla_priv *tabla,
1308 u32 jack_status, int irq)
1309{
1310 struct snd_soc_codec *codec;
1311
1312 if (tabla) {
1313 pr_info("%s: clear ocp status %x\n", __func__, jack_status);
1314 codec = tabla->codec;
1315 tabla->hph_status &= ~jack_status;
1316 if (tabla->headset_jack)
1317 snd_soc_jack_report(tabla->headset_jack,
1318 tabla->hph_status, TABLA_JACK_MASK);
1319 snd_soc_update_bits(codec, TABLA_A_RX_HPH_OCP_CTL, 0x10,
1320 0x00);
1321 snd_soc_update_bits(codec, TABLA_A_RX_HPH_OCP_CTL, 0x10,
1322 0x10);
1323 tabla_enable_irq(codec->control_data, irq);
1324 } else {
1325 pr_err("%s: Bad tabla private data\n", __func__);
1326 }
1327}
1328
1329static void hphlocp_off_report(struct work_struct *work)
1330{
1331 struct tabla_priv *tabla = container_of(work, struct tabla_priv,
1332 hphlocp_work);
1333 hphocp_off_report(tabla, SND_JACK_OC_HPHL, TABLA_IRQ_HPH_PA_OCPL_FAULT);
1334}
1335
1336static void hphrocp_off_report(struct work_struct *work)
1337{
1338 struct tabla_priv *tabla = container_of(work, struct tabla_priv,
1339 hphrocp_work);
1340 hphocp_off_report(tabla, SND_JACK_OC_HPHR, TABLA_IRQ_HPH_PA_OCPR_FAULT);
1341}
1342
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001343static int tabla_hph_pa_event(struct snd_soc_dapm_widget *w,
1344 struct snd_kcontrol *kcontrol, int event)
1345{
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001346 struct snd_soc_codec *codec = w->codec;
1347 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1348 u8 mbhc_micb_ctl_val;
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001349 pr_debug("%s: event = %d\n", __func__, event);
1350
1351 switch (event) {
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001352 case SND_SOC_DAPM_PRE_PMU:
1353 mbhc_micb_ctl_val = snd_soc_read(codec,
1354 tabla->mbhc_bias_regs.ctl_reg);
1355
1356 if (!(mbhc_micb_ctl_val & 0x80)
1357 && !tabla->mbhc_micbias_switched)
1358 tabla_codec_switch_micbias(codec, 1);
1359
1360 break;
1361
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001362 case SND_SOC_DAPM_POST_PMD:
Patrick Lai49efeac2011-11-03 11:01:12 -07001363 /* schedule work is required because at the time HPH PA DAPM
1364 * event callback is called by DAPM framework, CODEC dapm mutex
1365 * would have been locked while snd_soc_jack_report also
1366 * attempts to acquire same lock.
1367 */
1368 if ((tabla->hph_status & SND_JACK_OC_HPHL) &&
1369 strnstr(w->name, "HPHL", 4))
1370 schedule_work(&tabla->hphlocp_work);
1371 else if ((tabla->hph_status & SND_JACK_OC_HPHR) &&
1372 strnstr(w->name, "HPHR", 4))
1373 schedule_work(&tabla->hphrocp_work);
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001374 if (tabla->mbhc_micbias_switched)
1375 tabla_codec_switch_micbias(codec, 0);
1376
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001377 pr_debug("%s: sleep 10 ms after %s PA disable.\n", __func__,
1378 w->name);
1379 usleep_range(10000, 10000);
1380
1381 break;
1382 }
1383 return 0;
1384}
1385
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07001386static void tabla_get_mbhc_micbias_regs(struct snd_soc_codec *codec,
1387 struct mbhc_micbias_regs *micbias_regs)
1388{
1389 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
1390 struct tabla_mbhc_calibration *calibration = tabla->calibration;
1391 unsigned int cfilt;
1392
1393 switch (calibration->bias) {
1394 case TABLA_MICBIAS1:
1395 cfilt = tabla->pdata->micbias.bias1_cfilt_sel;
1396 micbias_regs->mbhc_reg = TABLA_A_MICB_1_MBHC;
1397 micbias_regs->int_rbias = TABLA_A_MICB_1_INT_RBIAS;
1398 micbias_regs->ctl_reg = TABLA_A_MICB_1_CTL;
1399 break;
1400 case TABLA_MICBIAS2:
1401 cfilt = tabla->pdata->micbias.bias2_cfilt_sel;
1402 micbias_regs->mbhc_reg = TABLA_A_MICB_2_MBHC;
1403 micbias_regs->int_rbias = TABLA_A_MICB_2_INT_RBIAS;
1404 micbias_regs->ctl_reg = TABLA_A_MICB_2_CTL;
1405 break;
1406 case TABLA_MICBIAS3:
1407 cfilt = tabla->pdata->micbias.bias3_cfilt_sel;
1408 micbias_regs->mbhc_reg = TABLA_A_MICB_3_MBHC;
1409 micbias_regs->int_rbias = TABLA_A_MICB_3_INT_RBIAS;
1410 micbias_regs->ctl_reg = TABLA_A_MICB_3_CTL;
1411 break;
1412 case TABLA_MICBIAS4:
1413 cfilt = tabla->pdata->micbias.bias4_cfilt_sel;
1414 micbias_regs->mbhc_reg = TABLA_A_MICB_4_MBHC;
1415 micbias_regs->int_rbias = TABLA_A_MICB_4_INT_RBIAS;
1416 micbias_regs->ctl_reg = TABLA_A_MICB_4_CTL;
1417 break;
1418 default:
1419 /* Should never reach here */
1420 pr_err("%s: Invalid MIC BIAS for MBHC\n", __func__);
1421 }
1422
1423 switch (cfilt) {
1424 case TABLA_CFILT1_SEL:
1425 micbias_regs->cfilt_val = TABLA_A_MICB_CFILT_1_VAL;
1426 micbias_regs->cfilt_ctl = TABLA_A_MICB_CFILT_1_CTL;
1427 break;
1428 case TABLA_CFILT2_SEL:
1429 micbias_regs->cfilt_val = TABLA_A_MICB_CFILT_2_VAL;
1430 micbias_regs->cfilt_ctl = TABLA_A_MICB_CFILT_2_CTL;
1431 break;
1432 case TABLA_CFILT3_SEL:
1433 micbias_regs->cfilt_val = TABLA_A_MICB_CFILT_3_VAL;
1434 micbias_regs->cfilt_ctl = TABLA_A_MICB_CFILT_3_CTL;
1435 break;
1436 }
1437}
Santosh Mardie15e2302011-11-15 10:39:23 +05301438static const struct snd_soc_dapm_widget tabla_dapm_i2s_widgets[] = {
1439 SND_SOC_DAPM_SUPPLY("RX_I2S_CLK", TABLA_A_CDC_CLK_RX_I2S_CTL,
1440 4, 0, NULL, 0),
1441 SND_SOC_DAPM_SUPPLY("TX_I2S_CLK", TABLA_A_CDC_CLK_TX_I2S_CTL, 4,
1442 0, NULL, 0),
1443};
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07001444
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001445static const struct snd_soc_dapm_widget tabla_dapm_widgets[] = {
1446 /*RX stuff */
1447 SND_SOC_DAPM_OUTPUT("EAR"),
1448
Kiran Kandid2d86b52011-09-09 17:44:28 -07001449 SND_SOC_DAPM_PGA("EAR PA", TABLA_A_RX_EAR_EN, 4, 0, NULL, 0),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001450
Bradley Rubin229c6a52011-07-12 16:18:48 -07001451 SND_SOC_DAPM_MIXER("DAC1", TABLA_A_RX_EAR_EN, 6, 0, dac1_switch,
1452 ARRAY_SIZE(dac1_switch)),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001453
Bradley Rubin229c6a52011-07-12 16:18:48 -07001454 SND_SOC_DAPM_AIF_IN("SLIM RX1", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1455 SND_SOC_DAPM_AIF_IN("SLIM RX2", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
Santosh Mardie15e2302011-11-15 10:39:23 +05301456 SND_SOC_DAPM_AIF_IN("SLIM RX3", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1457 SND_SOC_DAPM_AIF_IN("SLIM RX4", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001458
1459 /* Headphone */
1460 SND_SOC_DAPM_OUTPUT("HEADPHONE"),
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001461 SND_SOC_DAPM_PGA_E("HPHL", TABLA_A_RX_HPH_CNP_EN, 5, 0, NULL, 0,
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001462 tabla_hph_pa_event, SND_SOC_DAPM_PRE_PMU |
1463 SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001464 SND_SOC_DAPM_MIXER("HPHL DAC", TABLA_A_RX_HPH_L_DAC_CTL, 7, 0,
1465 hphl_switch, ARRAY_SIZE(hphl_switch)),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001466
Kiran Kandibf0b1ff2011-09-15 13:55:21 -07001467 SND_SOC_DAPM_PGA_E("HPHR", TABLA_A_RX_HPH_CNP_EN, 4, 0, NULL, 0,
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07001468 tabla_hph_pa_event, SND_SOC_DAPM_PRE_PMU |
1469 SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001470 SND_SOC_DAPM_MIXER("HPHR DAC", TABLA_A_RX_HPH_R_DAC_CTL, 7, 0,
1471 hphr_switch, ARRAY_SIZE(hphr_switch)),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001472
1473 /* Speaker */
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001474 SND_SOC_DAPM_OUTPUT("LINEOUT1"),
1475 SND_SOC_DAPM_OUTPUT("LINEOUT2"),
1476 SND_SOC_DAPM_OUTPUT("LINEOUT3"),
1477 SND_SOC_DAPM_OUTPUT("LINEOUT4"),
1478 SND_SOC_DAPM_OUTPUT("LINEOUT5"),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001479
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001480 SND_SOC_DAPM_PGA_E("LINEOUT1 PA", TABLA_A_RX_LINE_CNP_EN, 0, 0, NULL,
1481 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1482 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1483 SND_SOC_DAPM_PGA_E("LINEOUT2 PA", TABLA_A_RX_LINE_CNP_EN, 1, 0, NULL,
1484 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1485 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1486 SND_SOC_DAPM_PGA_E("LINEOUT3 PA", TABLA_A_RX_LINE_CNP_EN, 2, 0, NULL,
1487 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1488 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1489 SND_SOC_DAPM_PGA_E("LINEOUT4 PA", TABLA_A_RX_LINE_CNP_EN, 3, 0, NULL,
1490 0, tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1491 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1492 SND_SOC_DAPM_PGA_E("LINEOUT5 PA", TABLA_A_RX_LINE_CNP_EN, 4, 0, NULL, 0,
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001493 tabla_codec_enable_lineout, SND_SOC_DAPM_PRE_PMU |
1494 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001495
Bradley Rubin229c6a52011-07-12 16:18:48 -07001496 SND_SOC_DAPM_MIXER("LINEOUT1 DAC", TABLA_A_RX_LINE_1_DAC_CTL, 7, 0,
1497 lineout1_switch, ARRAY_SIZE(lineout1_switch)),
1498 SND_SOC_DAPM_MIXER("LINEOUT2 DAC", TABLA_A_RX_LINE_2_DAC_CTL, 7, 0,
1499 lineout2_switch, ARRAY_SIZE(lineout2_switch)),
1500 SND_SOC_DAPM_MIXER("LINEOUT3 DAC", TABLA_A_RX_LINE_3_DAC_CTL, 7, 0,
1501 lineout3_switch, ARRAY_SIZE(lineout3_switch)),
1502 SND_SOC_DAPM_MIXER("LINEOUT4 DAC", TABLA_A_RX_LINE_4_DAC_CTL, 7, 0,
1503 lineout4_switch, ARRAY_SIZE(lineout4_switch)),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001504 SND_SOC_DAPM_MIXER("LINEOUT5 DAC", TABLA_A_RX_LINE_5_DAC_CTL, 7, 0,
1505 lineout5_switch, ARRAY_SIZE(lineout5_switch)),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001506
Bradley Rubin229c6a52011-07-12 16:18:48 -07001507 SND_SOC_DAPM_MIXER_E("RX1 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 0, 0, NULL,
1508 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1509 SND_SOC_DAPM_MIXER_E("RX2 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 1, 0, NULL,
1510 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1511 SND_SOC_DAPM_MIXER_E("RX3 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 2, 0, NULL,
1512 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1513 SND_SOC_DAPM_MIXER_E("RX4 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 3, 0, NULL,
1514 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1515 SND_SOC_DAPM_MIXER_E("RX5 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 4, 0, NULL,
1516 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
1517 SND_SOC_DAPM_MIXER_E("RX6 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 5, 0, NULL,
1518 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001519 SND_SOC_DAPM_MIXER_E("RX7 MIX1", TABLA_A_CDC_CLK_RX_B1_CTL, 6, 0, NULL,
1520 0, tabla_codec_reset_interpolator, SND_SOC_DAPM_PRE_PMU),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001521
Bradley Rubin229c6a52011-07-12 16:18:48 -07001522 SND_SOC_DAPM_MIXER("RX1 CHAIN", TABLA_A_CDC_RX1_B6_CTL, 5, 0, NULL, 0),
1523 SND_SOC_DAPM_MIXER("RX2 CHAIN", TABLA_A_CDC_RX2_B6_CTL, 5, 0, NULL, 0),
1524
1525 SND_SOC_DAPM_MUX("RX1 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1526 &rx_mix1_inp1_mux),
1527 SND_SOC_DAPM_MUX("RX1 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1528 &rx_mix1_inp2_mux),
1529 SND_SOC_DAPM_MUX("RX2 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1530 &rx2_mix1_inp1_mux),
1531 SND_SOC_DAPM_MUX("RX2 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1532 &rx2_mix1_inp2_mux),
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001533 SND_SOC_DAPM_MUX("RX3 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1534 &rx3_mix1_inp1_mux),
1535 SND_SOC_DAPM_MUX("RX3 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1536 &rx3_mix1_inp2_mux),
1537 SND_SOC_DAPM_MUX("RX4 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1538 &rx4_mix1_inp1_mux),
1539 SND_SOC_DAPM_MUX("RX4 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1540 &rx4_mix1_inp2_mux),
1541 SND_SOC_DAPM_MUX("RX5 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1542 &rx5_mix1_inp1_mux),
1543 SND_SOC_DAPM_MUX("RX5 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1544 &rx5_mix1_inp2_mux),
1545 SND_SOC_DAPM_MUX("RX6 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1546 &rx6_mix1_inp1_mux),
1547 SND_SOC_DAPM_MUX("RX6 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1548 &rx6_mix1_inp2_mux),
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001549 SND_SOC_DAPM_MUX("RX7 MIX1 INP1", SND_SOC_NOPM, 0, 0,
1550 &rx7_mix1_inp1_mux),
1551 SND_SOC_DAPM_MUX("RX7 MIX1 INP2", SND_SOC_NOPM, 0, 0,
1552 &rx7_mix1_inp2_mux),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001553
Bradley Rubin229c6a52011-07-12 16:18:48 -07001554 SND_SOC_DAPM_SUPPLY("CP", TABLA_A_CP_EN, 0, 0,
1555 tabla_codec_enable_charge_pump, SND_SOC_DAPM_POST_PMU |
1556 SND_SOC_DAPM_PRE_PMD),
1557
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001558 SND_SOC_DAPM_SUPPLY("RX_BIAS", SND_SOC_NOPM, 0, 0,
1559 tabla_codec_enable_rx_bias, SND_SOC_DAPM_PRE_PMU |
1560 SND_SOC_DAPM_POST_PMD),
1561
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001562 /* TX */
Bradley Rubin229c6a52011-07-12 16:18:48 -07001563
Bradley Rubine1d08622011-07-20 18:01:35 -07001564 SND_SOC_DAPM_SUPPLY("CDC_CONN", TABLA_A_CDC_CLK_OTHR_CTL, 2, 0, NULL,
1565 0),
1566
Bradley Rubin229c6a52011-07-12 16:18:48 -07001567 SND_SOC_DAPM_SUPPLY("LDO_H", TABLA_A_LDO_H_MODE_1, 7, 0,
1568 tabla_codec_enable_ldo_h, SND_SOC_DAPM_POST_PMU),
1569
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001570 SND_SOC_DAPM_INPUT("AMIC1"),
1571 SND_SOC_DAPM_MICBIAS_E("MIC BIAS1 External", TABLA_A_MICB_1_CTL, 7, 0,
1572 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001573 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001574 SND_SOC_DAPM_MICBIAS_E("MIC BIAS1 Internal1", TABLA_A_MICB_1_CTL, 7, 0,
1575 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001576 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001577 SND_SOC_DAPM_MICBIAS_E("MIC BIAS1 Internal2", TABLA_A_MICB_1_CTL, 7, 0,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001578 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001579 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001580 SND_SOC_DAPM_ADC_E("ADC1", NULL, TABLA_A_TX_1_2_EN, 7, 0,
1581 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1582 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1583
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001584 SND_SOC_DAPM_INPUT("AMIC3"),
1585 SND_SOC_DAPM_ADC_E("ADC3", NULL, TABLA_A_TX_3_4_EN, 7, 0,
1586 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1587 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1588
1589 SND_SOC_DAPM_INPUT("AMIC4"),
1590 SND_SOC_DAPM_ADC_E("ADC4", NULL, TABLA_A_TX_3_4_EN, 3, 0,
1591 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1592 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1593
1594 SND_SOC_DAPM_MICBIAS_E("MIC BIAS4 External", TABLA_A_MICB_4_CTL, 7, 0,
1595 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001596 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001597
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001598 SND_SOC_DAPM_INPUT("AMIC5"),
1599 SND_SOC_DAPM_ADC_E("ADC5", NULL, TABLA_A_TX_5_6_EN, 7, 0,
1600 tabla_codec_enable_adc, SND_SOC_DAPM_POST_PMU),
1601
1602 SND_SOC_DAPM_INPUT("AMIC6"),
1603 SND_SOC_DAPM_ADC_E("ADC6", NULL, TABLA_A_TX_5_6_EN, 3, 0,
1604 tabla_codec_enable_adc, SND_SOC_DAPM_POST_PMU),
1605
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001606 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 -07001607 &dec1_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001608
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001609 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 -07001610 &dec2_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001611
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001612 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 -07001613 &dec3_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001614
1615 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 -07001616 &dec4_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001617
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001618 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 -07001619 &dec5_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001620
1621 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 -07001622 &dec6_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001623
1624 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 -07001625 &dec7_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001626
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001627 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 -07001628 &dec8_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001629
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001630 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 -07001631 &dec9_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001632
1633 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 -07001634 &dec10_mux, tabla_codec_enable_dec, SND_SOC_DAPM_PRE_PMU),
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001635
Bradley Rubin229c6a52011-07-12 16:18:48 -07001636 SND_SOC_DAPM_MUX("ANC1 MUX", SND_SOC_NOPM, 0, 0, &anc1_mux),
1637 SND_SOC_DAPM_MUX("ANC2 MUX", SND_SOC_NOPM, 0, 0, &anc2_mux),
1638
1639 SND_SOC_DAPM_MIXER_E("ANC", SND_SOC_NOPM, 0, 0, NULL, 0,
1640 tabla_codec_enable_anc, SND_SOC_DAPM_PRE_PMU |
1641 SND_SOC_DAPM_POST_PMD),
1642
1643 SND_SOC_DAPM_MUX("ANC1 FB MUX", SND_SOC_NOPM, 0, 0, &anc1_fb_mux),
1644
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001645 SND_SOC_DAPM_INPUT("AMIC2"),
1646 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 External", TABLA_A_MICB_2_CTL, 7, 0,
1647 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001648 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001649 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 Internal1", TABLA_A_MICB_2_CTL, 7, 0,
1650 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001651 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001652 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 Internal2", TABLA_A_MICB_2_CTL, 7, 0,
1653 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001654 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001655 SND_SOC_DAPM_MICBIAS_E("MIC BIAS2 Internal3", TABLA_A_MICB_2_CTL, 7, 0,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001656 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001657 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001658 SND_SOC_DAPM_MICBIAS_E("MIC BIAS3 External", TABLA_A_MICB_3_CTL, 7, 0,
1659 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001660 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001661 SND_SOC_DAPM_MICBIAS_E("MIC BIAS3 Internal1", TABLA_A_MICB_3_CTL, 7, 0,
1662 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001663 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bradley Rubin229c6a52011-07-12 16:18:48 -07001664 SND_SOC_DAPM_MICBIAS_E("MIC BIAS3 Internal2", TABLA_A_MICB_3_CTL, 7, 0,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001665 tabla_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
Bradley Rubin4d09cf42011-08-17 17:59:16 -07001666 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001667 SND_SOC_DAPM_ADC_E("ADC2", NULL, TABLA_A_TX_1_2_EN, 3, 0,
1668 tabla_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
1669 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1670
1671 SND_SOC_DAPM_MUX("SLIM TX1 MUX", SND_SOC_NOPM, 0, 0, &sb_tx1_mux),
1672 SND_SOC_DAPM_AIF_OUT("SLIM TX1", "AIF1 Capture", NULL, SND_SOC_NOPM,
1673 0, 0),
1674
1675 SND_SOC_DAPM_MUX("SLIM TX5 MUX", SND_SOC_NOPM, 0, 0, &sb_tx5_mux),
1676 SND_SOC_DAPM_AIF_OUT("SLIM TX5", "AIF1 Capture", NULL, SND_SOC_NOPM,
1677 4, 0),
1678
1679 SND_SOC_DAPM_MUX("SLIM TX6 MUX", SND_SOC_NOPM, 0, 0, &sb_tx6_mux),
1680 SND_SOC_DAPM_AIF_OUT("SLIM TX6", "AIF1 Capture", NULL, SND_SOC_NOPM,
1681 5, 0),
1682
1683 SND_SOC_DAPM_MUX("SLIM TX7 MUX", SND_SOC_NOPM, 0, 0, &sb_tx7_mux),
1684 SND_SOC_DAPM_AIF_OUT("SLIM TX7", "AIF1 Capture", NULL, SND_SOC_NOPM,
1685 0, 0),
1686
1687 SND_SOC_DAPM_MUX("SLIM TX8 MUX", SND_SOC_NOPM, 0, 0, &sb_tx8_mux),
1688 SND_SOC_DAPM_AIF_OUT("SLIM TX8", "AIF1 Capture", NULL, SND_SOC_NOPM,
1689 0, 0),
1690
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001691 /* Digital Mic Inputs */
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001692 SND_SOC_DAPM_ADC_E("DMIC1", NULL, SND_SOC_NOPM, 0, 0,
1693 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1694 SND_SOC_DAPM_POST_PMD),
1695
1696 SND_SOC_DAPM_ADC_E("DMIC2", NULL, SND_SOC_NOPM, 0, 0,
1697 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1698 SND_SOC_DAPM_POST_PMD),
1699
1700 SND_SOC_DAPM_ADC_E("DMIC3", NULL, SND_SOC_NOPM, 0, 0,
1701 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1702 SND_SOC_DAPM_POST_PMD),
1703
1704 SND_SOC_DAPM_ADC_E("DMIC4", NULL, SND_SOC_NOPM, 0, 0,
1705 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1706 SND_SOC_DAPM_POST_PMD),
1707
1708 SND_SOC_DAPM_ADC_E("DMIC5", NULL, SND_SOC_NOPM, 0, 0,
1709 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1710 SND_SOC_DAPM_POST_PMD),
1711
1712 SND_SOC_DAPM_ADC_E("DMIC6", NULL, SND_SOC_NOPM, 0, 0,
1713 tabla_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
1714 SND_SOC_DAPM_POST_PMD),
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001715
1716 /* Sidetone */
1717 SND_SOC_DAPM_MUX("IIR1 INP1 MUX", SND_SOC_NOPM, 0, 0, &iir1_inp1_mux),
1718 SND_SOC_DAPM_PGA("IIR1", TABLA_A_CDC_CLK_SD_CTL, 0, 0, NULL, 0),
1719};
1720
Santosh Mardie15e2302011-11-15 10:39:23 +05301721static const struct snd_soc_dapm_route audio_i2s_map[] = {
1722 {"RX_I2S_CLK", NULL, "CDC_CONN"},
1723 {"SLIM RX1", NULL, "RX_I2S_CLK"},
1724 {"SLIM RX2", NULL, "RX_I2S_CLK"},
1725 {"SLIM RX3", NULL, "RX_I2S_CLK"},
1726 {"SLIM RX4", NULL, "RX_I2S_CLK"},
1727
1728 {"SLIM TX7", NULL, "TX_I2S_CLK"},
1729 {"SLIM TX8", NULL, "TX_I2S_CLK"},
1730 {"SLIM TX9", NULL, "TX_I2S_CLK"},
1731 {"SLIM TX10", NULL, "TX_I2S_CLK"},
1732};
1733
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001734static const struct snd_soc_dapm_route audio_map[] = {
1735 /* SLIMBUS Connections */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001736
1737 {"SLIM TX1", NULL, "SLIM TX1 MUX"},
1738 {"SLIM TX1 MUX", "DEC1", "DEC1 MUX"},
1739
1740 {"SLIM TX5", NULL, "SLIM TX5 MUX"},
1741 {"SLIM TX5 MUX", "DEC5", "DEC5 MUX"},
1742
1743 {"SLIM TX6", NULL, "SLIM TX6 MUX"},
1744 {"SLIM TX6 MUX", "DEC6", "DEC6 MUX"},
1745
1746 {"SLIM TX7", NULL, "SLIM TX7 MUX"},
1747 {"SLIM TX7 MUX", "DEC1", "DEC1 MUX"},
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001748 {"SLIM TX7 MUX", "DEC2", "DEC2 MUX"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001749 {"SLIM TX7 MUX", "DEC3", "DEC3 MUX"},
1750 {"SLIM TX7 MUX", "DEC4", "DEC4 MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001751 {"SLIM TX7 MUX", "DEC5", "DEC5 MUX"},
1752 {"SLIM TX7 MUX", "DEC6", "DEC6 MUX"},
Bhalchandra Gajare0d77e1b2011-07-08 10:54:14 -07001753 {"SLIM TX7 MUX", "DEC7", "DEC7 MUX"},
1754 {"SLIM TX7 MUX", "DEC8", "DEC8 MUX"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001755 {"SLIM TX7 MUX", "DEC9", "DEC9 MUX"},
1756 {"SLIM TX7 MUX", "DEC10", "DEC10 MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001757
1758 {"SLIM TX8", NULL, "SLIM TX8 MUX"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001759 {"SLIM TX8 MUX", "DEC1", "DEC1 MUX"},
1760 {"SLIM TX8 MUX", "DEC2", "DEC2 MUX"},
1761 {"SLIM TX8 MUX", "DEC3", "DEC3 MUX"},
Bhalchandra Gajare9ec83cd2011-09-23 17:25:07 -07001762 {"SLIM TX8 MUX", "DEC4", "DEC4 MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001763 {"SLIM TX8 MUX", "DEC5", "DEC5 MUX"},
1764 {"SLIM TX8 MUX", "DEC6", "DEC6 MUX"},
1765
1766 /* Earpiece (RX MIX1) */
1767 {"EAR", NULL, "EAR PA"},
Kiran Kandiac034ac2011-07-29 16:39:08 -07001768 {"EAR PA", NULL, "DAC1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001769 {"DAC1", NULL, "CP"},
1770
1771 {"ANC1 FB MUX", "EAR_HPH_L", "RX1 MIX1"},
1772 {"ANC1 FB MUX", "EAR_LINE_1", "RX2 MIX1"},
1773 {"ANC", NULL, "ANC1 FB MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001774
1775 /* Headset (RX MIX1 and RX MIX2) */
1776 {"HEADPHONE", NULL, "HPHL"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001777 {"HEADPHONE", NULL, "HPHR"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001778
1779 {"HPHL", NULL, "HPHL DAC"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001780 {"HPHR", NULL, "HPHR DAC"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001781
1782 {"HPHL DAC", NULL, "CP"},
1783 {"HPHR DAC", NULL, "CP"},
1784
1785 {"ANC", NULL, "ANC1 MUX"},
1786 {"ANC", NULL, "ANC2 MUX"},
1787 {"ANC1 MUX", "ADC1", "ADC1"},
1788 {"ANC1 MUX", "ADC2", "ADC2"},
1789 {"ANC1 MUX", "ADC3", "ADC3"},
1790 {"ANC1 MUX", "ADC4", "ADC4"},
1791 {"ANC2 MUX", "ADC1", "ADC1"},
1792 {"ANC2 MUX", "ADC2", "ADC2"},
1793 {"ANC2 MUX", "ADC3", "ADC3"},
1794 {"ANC2 MUX", "ADC4", "ADC4"},
1795
Bradley Rubine1d08622011-07-20 18:01:35 -07001796 {"ANC", NULL, "CDC_CONN"},
1797
Bradley Rubin229c6a52011-07-12 16:18:48 -07001798 {"DAC1", "Switch", "RX1 CHAIN"},
1799 {"HPHL DAC", "Switch", "RX1 CHAIN"},
1800 {"HPHR DAC", "Switch", "RX2 CHAIN"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001801
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001802 {"LINEOUT1", NULL, "LINEOUT1 PA"},
1803 {"LINEOUT2", NULL, "LINEOUT2 PA"},
1804 {"LINEOUT3", NULL, "LINEOUT3 PA"},
1805 {"LINEOUT4", NULL, "LINEOUT4 PA"},
1806 {"LINEOUT5", NULL, "LINEOUT5 PA"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001807
Kiran Kandidb0a4b02011-08-23 09:32:09 -07001808 {"LINEOUT1 PA", NULL, "LINEOUT1 DAC"},
1809 {"LINEOUT2 PA", NULL, "LINEOUT2 DAC"},
1810 {"LINEOUT3 PA", NULL, "LINEOUT3 DAC"},
1811 {"LINEOUT4 PA", NULL, "LINEOUT4 DAC"},
1812 {"LINEOUT5 PA", NULL, "LINEOUT5 DAC"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001813
Bradley Rubin229c6a52011-07-12 16:18:48 -07001814 {"RX1 CHAIN", NULL, "RX1 MIX1"},
1815 {"RX2 CHAIN", NULL, "RX2 MIX1"},
1816 {"RX1 CHAIN", NULL, "ANC"},
1817 {"RX2 CHAIN", NULL, "ANC"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001818 {"LINEOUT1 DAC", "Switch", "RX3 MIX1"},
1819 {"LINEOUT2 DAC", "Switch", "RX4 MIX1"},
Kiran Kandied246a92011-08-12 14:03:44 -07001820 {"LINEOUT3 DAC", "Switch", "RX3 MIX1"},
1821 {"LINEOUT4 DAC", "Switch", "RX4 MIX1"},
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001822 {"LINEOUT5 DAC", "Switch", "RX7 MIX1"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001823
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07001824 {"CP", NULL, "RX_BIAS"},
1825 {"LINEOUT1 DAC", NULL, "RX_BIAS"},
1826 {"LINEOUT2 DAC", NULL, "RX_BIAS"},
1827 {"LINEOUT3 DAC", NULL, "RX_BIAS"},
1828 {"LINEOUT4 DAC", NULL, "RX_BIAS"},
1829
Bradley Rubin229c6a52011-07-12 16:18:48 -07001830 {"RX1 MIX1", NULL, "RX1 MIX1 INP1"},
1831 {"RX1 MIX1", NULL, "RX1 MIX1 INP2"},
1832 {"RX2 MIX1", NULL, "RX2 MIX1 INP1"},
1833 {"RX2 MIX1", NULL, "RX2 MIX1 INP2"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001834 {"RX3 MIX1", NULL, "RX3 MIX1 INP1"},
1835 {"RX3 MIX1", NULL, "RX3 MIX1 INP2"},
1836 {"RX4 MIX1", NULL, "RX4 MIX1 INP1"},
1837 {"RX4 MIX1", NULL, "RX4 MIX1 INP2"},
1838 {"RX5 MIX1", NULL, "RX5 MIX1 INP1"},
1839 {"RX5 MIX1", NULL, "RX5 MIX1 INP2"},
1840 {"RX6 MIX1", NULL, "RX6 MIX1 INP1"},
1841 {"RX6 MIX1", NULL, "RX6 MIX1 INP2"},
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001842 {"RX7 MIX1", NULL, "RX7 MIX1 INP1"},
1843 {"RX7 MIX1", NULL, "RX7 MIX1 INP2"},
Bradley Rubin74a9b4a2011-06-13 15:03:43 -07001844
Bradley Rubin229c6a52011-07-12 16:18:48 -07001845 {"RX1 MIX1 INP1", "RX1", "SLIM RX1"},
1846 {"RX1 MIX1 INP1", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301847 {"RX1 MIX1 INP1", "RX3", "SLIM RX3"},
1848 {"RX1 MIX1 INP1", "RX4", "SLIM RX4"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001849 {"RX1 MIX1 INP1", "IIR1", "IIR1"},
1850 {"RX1 MIX1 INP2", "RX1", "SLIM RX1"},
1851 {"RX1 MIX1 INP2", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301852 {"RX1 MIX1 INP2", "RX3", "SLIM RX3"},
1853 {"RX1 MIX1 INP2", "RX4", "SLIM RX4"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001854 {"RX1 MIX1 INP2", "IIR1", "IIR1"},
1855 {"RX2 MIX1 INP1", "RX1", "SLIM RX1"},
1856 {"RX2 MIX1 INP1", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301857 {"RX2 MIX1 INP1", "RX3", "SLIM RX3"},
1858 {"RX2 MIX1 INP1", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001859 {"RX2 MIX1 INP1", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001860 {"RX2 MIX1 INP2", "RX1", "SLIM RX1"},
1861 {"RX2 MIX1 INP2", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301862 {"RX2 MIX1 INP2", "RX3", "SLIM RX3"},
1863 {"RX2 MIX1 INP2", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001864 {"RX2 MIX1 INP2", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001865 {"RX3 MIX1 INP1", "RX1", "SLIM RX1"},
1866 {"RX3 MIX1 INP1", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301867 {"RX3 MIX1 INP1", "RX3", "SLIM RX3"},
1868 {"RX3 MIX1 INP1", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001869 {"RX3 MIX1 INP1", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001870 {"RX3 MIX1 INP2", "RX1", "SLIM RX1"},
1871 {"RX3 MIX1 INP2", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301872 {"RX3 MIX1 INP2", "RX3", "SLIM RX3"},
1873 {"RX3 MIX1 INP2", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001874 {"RX3 MIX1 INP2", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001875 {"RX4 MIX1 INP1", "RX1", "SLIM RX1"},
1876 {"RX4 MIX1 INP1", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301877 {"RX4 MIX1 INP1", "RX3", "SLIM RX3"},
1878 {"RX4 MIX1 INP1", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001879 {"RX4 MIX1 INP1", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001880 {"RX4 MIX1 INP2", "RX1", "SLIM RX1"},
1881 {"RX4 MIX1 INP2", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301882 {"RX4 MIX1 INP2", "RX3", "SLIM RX3"},
1883 {"RX4 MIX1 INP2", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001884 {"RX4 MIX1 INP2", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001885 {"RX5 MIX1 INP1", "RX1", "SLIM RX1"},
1886 {"RX5 MIX1 INP1", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301887 {"RX5 MIX1 INP1", "RX3", "SLIM RX3"},
1888 {"RX5 MIX1 INP1", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001889 {"RX5 MIX1 INP1", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001890 {"RX5 MIX1 INP2", "RX1", "SLIM RX1"},
1891 {"RX5 MIX1 INP2", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301892 {"RX5 MIX1 INP2", "RX3", "SLIM RX3"},
1893 {"RX5 MIX1 INP2", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001894 {"RX5 MIX1 INP2", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001895 {"RX6 MIX1 INP1", "RX1", "SLIM RX1"},
1896 {"RX6 MIX1 INP1", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301897 {"RX6 MIX1 INP1", "RX3", "SLIM RX3"},
1898 {"RX6 MIX1 INP1", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001899 {"RX6 MIX1 INP1", "IIR1", "IIR1"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001900 {"RX6 MIX1 INP2", "RX1", "SLIM RX1"},
1901 {"RX6 MIX1 INP2", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301902 {"RX6 MIX1 INP2", "RX3", "SLIM RX3"},
1903 {"RX6 MIX1 INP2", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001904 {"RX6 MIX1 INP2", "IIR1", "IIR1"},
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001905 {"RX7 MIX1 INP1", "RX1", "SLIM RX1"},
1906 {"RX7 MIX1 INP1", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301907 {"RX7 MIX1 INP1", "RX3", "SLIM RX3"},
1908 {"RX7 MIX1 INP1", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001909 {"RX7 MIX1 INP1", "IIR1", "IIR1"},
Bhalchandra Gajare0a8ad172011-08-12 13:32:22 -07001910 {"RX7 MIX1 INP2", "RX1", "SLIM RX1"},
1911 {"RX7 MIX1 INP2", "RX2", "SLIM RX2"},
Santosh Mardie15e2302011-11-15 10:39:23 +05301912 {"RX7 MIX1 INP2", "RX3", "SLIM RX3"},
1913 {"RX7 MIX1 INP2", "RX4", "SLIM RX4"},
Patrick Lai16261e82011-09-30 13:25:52 -07001914 {"RX7 MIX1 INP2", "IIR1", "IIR1"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001915
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001916 /* Decimator Inputs */
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001917 {"DEC1 MUX", "DMIC1", "DMIC1"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001918 {"DEC1 MUX", "ADC6", "ADC6"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001919 {"DEC1 MUX", NULL, "CDC_CONN"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001920 {"DEC2 MUX", "DMIC2", "DMIC2"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001921 {"DEC2 MUX", "ADC5", "ADC5"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001922 {"DEC2 MUX", NULL, "CDC_CONN"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001923 {"DEC3 MUX", "DMIC3", "DMIC3"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001924 {"DEC3 MUX", "ADC4", "ADC4"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001925 {"DEC3 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001926 {"DEC4 MUX", "DMIC4", "DMIC4"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001927 {"DEC4 MUX", "ADC3", "ADC3"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001928 {"DEC4 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001929 {"DEC5 MUX", "DMIC5", "DMIC5"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001930 {"DEC5 MUX", "ADC2", "ADC2"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001931 {"DEC5 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajare7cf018e2011-08-11 18:58:32 -07001932 {"DEC6 MUX", "DMIC6", "DMIC6"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001933 {"DEC6 MUX", "ADC1", "ADC1"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001934 {"DEC6 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001935 {"DEC7 MUX", "DMIC1", "DMIC1"},
Kiran Kandicf45f6a2011-07-17 21:10:19 -07001936 {"DEC7 MUX", "ADC6", "ADC6"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001937 {"DEC7 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001938 {"DEC8 MUX", "ADC5", "ADC5"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001939 {"DEC8 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001940 {"DEC9 MUX", "ADC3", "ADC3"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001941 {"DEC9 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001942 {"DEC10 MUX", "ADC4", "ADC4"},
Bradley Rubine1d08622011-07-20 18:01:35 -07001943 {"DEC10 MUX", NULL, "CDC_CONN"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001944
1945 /* ADC Connections */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001946 {"ADC1", NULL, "AMIC1"},
1947 {"ADC2", NULL, "AMIC2"},
Bhalchandra Gajarecc6ffa02011-07-14 18:35:41 -07001948 {"ADC3", NULL, "AMIC3"},
1949 {"ADC4", NULL, "AMIC4"},
1950 {"ADC5", NULL, "AMIC5"},
1951 {"ADC6", NULL, "AMIC6"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001952
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001953 {"IIR1", NULL, "IIR1 INP1 MUX"},
Patrick Lai16261e82011-09-30 13:25:52 -07001954 {"IIR1 INP1 MUX", "DEC1", "DEC1 MUX"},
1955 {"IIR1 INP1 MUX", "DEC2", "DEC2 MUX"},
1956 {"IIR1 INP1 MUX", "DEC3", "DEC3 MUX"},
1957 {"IIR1 INP1 MUX", "DEC4", "DEC4 MUX"},
1958 {"IIR1 INP1 MUX", "DEC5", "DEC5 MUX"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001959 {"IIR1 INP1 MUX", "DEC6", "DEC6 MUX"},
Patrick Lai16261e82011-09-30 13:25:52 -07001960 {"IIR1 INP1 MUX", "DEC7", "DEC7 MUX"},
1961 {"IIR1 INP1 MUX", "DEC8", "DEC8 MUX"},
1962 {"IIR1 INP1 MUX", "DEC9", "DEC9 MUX"},
1963 {"IIR1 INP1 MUX", "DEC10", "DEC10 MUX"},
Bradley Rubin229c6a52011-07-12 16:18:48 -07001964
1965 {"MIC BIAS1 Internal1", NULL, "LDO_H"},
1966 {"MIC BIAS1 Internal2", NULL, "LDO_H"},
1967 {"MIC BIAS1 External", NULL, "LDO_H"},
1968 {"MIC BIAS2 Internal1", NULL, "LDO_H"},
1969 {"MIC BIAS2 Internal2", NULL, "LDO_H"},
1970 {"MIC BIAS2 Internal3", NULL, "LDO_H"},
1971 {"MIC BIAS2 External", NULL, "LDO_H"},
1972 {"MIC BIAS3 Internal1", NULL, "LDO_H"},
1973 {"MIC BIAS3 Internal2", NULL, "LDO_H"},
1974 {"MIC BIAS3 External", NULL, "LDO_H"},
1975 {"MIC BIAS4 External", NULL, "LDO_H"},
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001976};
1977
1978static int tabla_readable(struct snd_soc_codec *ssc, unsigned int reg)
1979{
1980 return tabla_reg_readable[reg];
1981}
1982
1983static int tabla_volatile(struct snd_soc_codec *ssc, unsigned int reg)
1984{
1985 /* Registers lower than 0x100 are top level registers which can be
1986 * written by the Tabla core driver.
1987 */
1988
1989 if ((reg >= TABLA_A_CDC_MBHC_EN_CTL) || (reg < 0x100))
1990 return 1;
1991
1992 return 0;
1993}
1994
1995#define TABLA_FORMATS (SNDRV_PCM_FMTBIT_S16_LE)
1996static int tabla_write(struct snd_soc_codec *codec, unsigned int reg,
1997 unsigned int value)
1998{
1999 int ret;
2000 pr_debug("%s: write reg %x val %x\n", __func__, reg, value);
2001
2002 BUG_ON(reg > TABLA_MAX_REGISTER);
2003
2004 if (!tabla_volatile(codec, reg)) {
2005 pr_debug("writing to cache\n");
2006 ret = snd_soc_cache_write(codec, reg, value);
2007 if (ret != 0)
2008 dev_err(codec->dev, "Cache write to %x failed: %d\n",
2009 reg, ret);
2010 }
2011
2012 return tabla_reg_write(codec->control_data, reg, value);
2013}
2014static unsigned int tabla_read(struct snd_soc_codec *codec,
2015 unsigned int reg)
2016{
2017 unsigned int val;
2018 int ret;
2019
2020 BUG_ON(reg > TABLA_MAX_REGISTER);
2021
2022 if (!tabla_volatile(codec, reg) && tabla_readable(codec, reg) &&
2023 reg < codec->driver->reg_cache_size) {
2024 pr_debug("reading from cache\n");
2025 ret = snd_soc_cache_read(codec, reg, &val);
2026 if (ret >= 0) {
Bradley Rubin229c6a52011-07-12 16:18:48 -07002027 pr_debug("register %x, value %x\n", reg, val);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002028 return val;
2029 } else
2030 dev_err(codec->dev, "Cache read from %x failed: %d\n",
2031 reg, ret);
2032 }
2033
2034 val = tabla_reg_read(codec->control_data, reg);
2035 pr_debug("%s: read reg %x val %x\n", __func__, reg, val);
2036 return val;
2037}
2038
2039static void tabla_codec_enable_audio_mode_bandgap(struct snd_soc_codec *codec)
2040{
2041 snd_soc_write(codec, TABLA_A_BIAS_REF_CTL, 0x1C);
2042 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
2043 0x80);
2044 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x04,
2045 0x04);
2046 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x01,
2047 0x01);
2048 usleep_range(1000, 1000);
2049 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
2050 0x00);
2051}
2052
2053static void tabla_codec_enable_bandgap(struct snd_soc_codec *codec,
2054 enum tabla_bandgap_type choice)
2055{
2056 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2057
2058 /* TODO lock resources accessed by audio streams and threaded
2059 * interrupt handlers
2060 */
2061
2062 pr_debug("%s, choice is %d, current is %d\n", __func__, choice,
2063 tabla->bandgap_type);
2064
2065 if (tabla->bandgap_type == choice)
2066 return;
2067
2068 if ((tabla->bandgap_type == TABLA_BANDGAP_OFF) &&
2069 (choice == TABLA_BANDGAP_AUDIO_MODE)) {
2070 tabla_codec_enable_audio_mode_bandgap(codec);
2071 } else if ((tabla->bandgap_type == TABLA_BANDGAP_AUDIO_MODE) &&
2072 (choice == TABLA_BANDGAP_MBHC_MODE)) {
2073 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x2,
2074 0x2);
2075 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
2076 0x80);
2077 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x4,
2078 0x4);
2079 usleep_range(1000, 1000);
2080 snd_soc_update_bits(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x80,
2081 0x00);
2082 } else if ((tabla->bandgap_type == TABLA_BANDGAP_MBHC_MODE) &&
2083 (choice == TABLA_BANDGAP_AUDIO_MODE)) {
2084 snd_soc_write(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x00);
2085 usleep_range(100, 100);
2086 tabla_codec_enable_audio_mode_bandgap(codec);
2087 } else if (choice == TABLA_BANDGAP_OFF) {
2088 snd_soc_write(codec, TABLA_A_BIAS_CENTRAL_BG_CTL, 0x00);
2089 } else {
2090 pr_err("%s: Error, Invalid bandgap settings\n", __func__);
2091 }
2092 tabla->bandgap_type = choice;
2093}
2094
2095static int tabla_codec_enable_config_mode(struct snd_soc_codec *codec,
2096 int enable)
2097{
2098 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2099
2100 if (enable) {
2101 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_FREQ, 0x10, 0);
2102 snd_soc_write(codec, TABLA_A_BIAS_CONFIG_MODE_BG_CTL, 0x17);
2103 usleep_range(5, 5);
2104 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_FREQ, 0x80,
2105 0x80);
2106 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_TEST, 0x80,
2107 0x80);
2108 usleep_range(10, 10);
2109 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_TEST, 0x80, 0);
2110 usleep_range(20, 20);
2111 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x08, 0x08);
2112 } else {
2113 snd_soc_update_bits(codec, TABLA_A_BIAS_CONFIG_MODE_BG_CTL, 0x1,
2114 0);
2115 snd_soc_update_bits(codec, TABLA_A_CONFIG_MODE_FREQ, 0x80, 0);
2116 }
2117 tabla->config_mode_active = enable ? true : false;
2118
2119 return 0;
2120}
2121
2122static int tabla_codec_enable_clock_block(struct snd_soc_codec *codec,
2123 int config_mode)
2124{
2125 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2126
2127 pr_debug("%s\n", __func__);
2128
2129 if (config_mode) {
2130 tabla_codec_enable_config_mode(codec, 1);
2131 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN2, 0x00);
2132 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN2, 0x02);
2133 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN1, 0x0D);
2134 usleep_range(1000, 1000);
2135 } else
2136 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x08, 0x00);
2137
2138 if (!config_mode && tabla->mbhc_polling_active) {
2139 snd_soc_write(codec, TABLA_A_CLK_BUFF_EN2, 0x02);
2140 tabla_codec_enable_config_mode(codec, 0);
2141
2142 }
2143
2144 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x05, 0x05);
2145 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x02, 0x00);
2146 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x04, 0x04);
2147 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_MCLK_CTL, 0x01, 0x01);
2148 usleep_range(50, 50);
2149 tabla->clock_active = true;
2150 return 0;
2151}
2152static void tabla_codec_disable_clock_block(struct snd_soc_codec *codec)
2153{
2154 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2155 pr_debug("%s\n", __func__);
2156 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x04, 0x00);
2157 ndelay(160);
2158 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN2, 0x02, 0x02);
2159 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x05, 0x00);
2160 tabla->clock_active = false;
2161}
2162
Bradley Rubincb1e2732011-06-23 16:49:20 -07002163static void tabla_codec_calibrate_hs_polling(struct snd_soc_codec *codec)
2164{
2165 /* TODO store register values in calibration */
Bhalchandra Gajare30cf4842011-10-17 18:12:52 -07002166 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B5_CTL, 0x20);
2167 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B6_CTL, 0xFF);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002168
2169 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B10_CTL, 0xFF);
Bhalchandra Gajare30cf4842011-10-17 18:12:52 -07002170 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B9_CTL, 0x20);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002171
Bhalchandra Gajarefabb8772011-11-10 19:52:01 -08002172 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B4_CTL, 0xF8);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002173 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B3_CTL, 0xEE);
2174 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B2_CTL, 0xFC);
2175 snd_soc_write(codec, TABLA_A_CDC_MBHC_VOLT_B1_CTL, 0xCE);
2176
2177 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B1_CTL, 3);
2178 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B2_CTL, 9);
2179 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B3_CTL, 30);
2180 snd_soc_write(codec, TABLA_A_CDC_MBHC_TIMER_B6_CTL, 120);
2181 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_TIMER_B1_CTL, 0x78, 0x58);
2182 snd_soc_write(codec, TABLA_A_CDC_MBHC_B2_CTL, 11);
2183}
2184
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002185static int tabla_startup(struct snd_pcm_substream *substream,
2186 struct snd_soc_dai *dai)
2187{
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002188 pr_debug("%s(): substream = %s stream = %d\n" , __func__,
2189 substream->name, substream->stream);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002190
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002191 return 0;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002192}
2193
2194static void tabla_shutdown(struct snd_pcm_substream *substream,
2195 struct snd_soc_dai *dai)
2196{
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002197 pr_debug("%s(): substream = %s stream = %d\n" , __func__,
2198 substream->name, substream->stream);
2199}
2200
2201int tabla_mclk_enable(struct snd_soc_codec *codec, int mclk_enable)
2202{
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002203 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2204
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002205 pr_debug("%s() mclk_enable = %u\n", __func__, mclk_enable);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002206
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002207 if (mclk_enable) {
2208 tabla->mclk_enabled = true;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002209
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002210 if (tabla->mbhc_polling_active && (tabla->mclk_enabled)) {
Bradley Rubincb1e2732011-06-23 16:49:20 -07002211 tabla_codec_pause_hs_polling(codec);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002212 tabla_codec_enable_bandgap(codec,
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002213 TABLA_BANDGAP_AUDIO_MODE);
2214 tabla_codec_enable_clock_block(codec, 0);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002215 tabla_codec_calibrate_hs_polling(codec);
2216 tabla_codec_start_hs_polling(codec);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002217 }
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002218 } else {
2219
2220 if (!tabla->mclk_enabled) {
2221 pr_err("Error, MCLK already diabled\n");
2222 return -EINVAL;
2223 }
2224 tabla->mclk_enabled = false;
2225
2226 if (tabla->mbhc_polling_active) {
2227 if (!tabla->mclk_enabled) {
2228 tabla_codec_pause_hs_polling(codec);
2229 tabla_codec_enable_bandgap(codec,
2230 TABLA_BANDGAP_MBHC_MODE);
2231 tabla_enable_rx_bias(codec, 1);
2232 tabla_codec_enable_clock_block(codec, 1);
2233 tabla_codec_calibrate_hs_polling(codec);
2234 tabla_codec_start_hs_polling(codec);
2235 }
2236 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1,
2237 0x05, 0x01);
2238 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002239 }
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002240 return 0;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002241}
2242
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002243static int tabla_set_dai_sysclk(struct snd_soc_dai *dai,
2244 int clk_id, unsigned int freq, int dir)
2245{
2246 pr_debug("%s\n", __func__);
2247 return 0;
2248}
2249
2250static int tabla_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2251{
Santosh Mardie15e2302011-11-15 10:39:23 +05302252 u8 val = 0;
2253 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(dai->codec);
2254
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002255 pr_debug("%s\n", __func__);
Santosh Mardie15e2302011-11-15 10:39:23 +05302256 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
2257 case SND_SOC_DAIFMT_CBS_CFS:
2258 /* CPU is master */
2259 if (tabla->intf_type == TABLA_INTERFACE_TYPE_I2C) {
2260 if (dai->id == TABLA_TX_DAI_ID)
2261 snd_soc_update_bits(dai->codec,
2262 TABLA_A_CDC_CLK_TX_I2S_CTL,
2263 TABLA_I2S_MASTER_MODE_MASK, 0);
2264 else if (dai->id == TABLA_RX_DAI_ID)
2265 snd_soc_update_bits(dai->codec,
2266 TABLA_A_CDC_CLK_RX_I2S_CTL,
2267 TABLA_I2S_MASTER_MODE_MASK, 0);
2268 }
2269 break;
2270 case SND_SOC_DAIFMT_CBM_CFM:
2271 /* CPU is slave */
2272 if (tabla->intf_type == TABLA_INTERFACE_TYPE_I2C) {
2273 val = TABLA_I2S_MASTER_MODE_MASK;
2274 if (dai->id == TABLA_TX_DAI_ID)
2275 snd_soc_update_bits(dai->codec,
2276 TABLA_A_CDC_CLK_TX_I2S_CTL, val, val);
2277 else if (dai->id == TABLA_RX_DAI_ID)
2278 snd_soc_update_bits(dai->codec,
2279 TABLA_A_CDC_CLK_RX_I2S_CTL, val, val);
2280 }
2281 break;
2282 default:
2283 return -EINVAL;
2284 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002285 return 0;
2286}
2287
2288static int tabla_hw_params(struct snd_pcm_substream *substream,
2289 struct snd_pcm_hw_params *params,
2290 struct snd_soc_dai *dai)
2291{
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07002292 struct snd_soc_codec *codec = dai->codec;
Santosh Mardie15e2302011-11-15 10:39:23 +05302293 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(dai->codec);
Bhalchandra Gajare038bf3a2011-09-02 15:32:30 -07002294 u8 path, shift;
2295 u16 tx_fs_reg, rx_fs_reg;
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07002296 u8 tx_fs_rate, rx_fs_rate, rx_state, tx_state;
2297
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002298 pr_debug("%s: DAI-ID %x\n", __func__, dai->id);
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07002299
2300 switch (params_rate(params)) {
2301 case 8000:
2302 tx_fs_rate = 0x00;
2303 rx_fs_rate = 0x00;
2304 break;
2305 case 16000:
2306 tx_fs_rate = 0x01;
2307 rx_fs_rate = 0x20;
2308 break;
2309 case 32000:
2310 tx_fs_rate = 0x02;
2311 rx_fs_rate = 0x40;
2312 break;
2313 case 48000:
2314 tx_fs_rate = 0x03;
2315 rx_fs_rate = 0x60;
2316 break;
2317 default:
2318 pr_err("%s: Invalid sampling rate %d\n", __func__,
2319 params_rate(params));
2320 return -EINVAL;
2321 }
2322
2323
2324 /**
2325 * If current dai is a tx dai, set sample rate to
2326 * all the txfe paths that are currently not active
2327 */
2328 if (dai->id == TABLA_TX_DAI_ID) {
2329
2330 tx_state = snd_soc_read(codec,
2331 TABLA_A_CDC_CLK_TX_CLK_EN_B1_CTL);
2332
2333 for (path = 1, shift = 0;
2334 path <= NUM_DECIMATORS; path++, shift++) {
2335
2336 if (path == BITS_PER_REG + 1) {
2337 shift = 0;
2338 tx_state = snd_soc_read(codec,
2339 TABLA_A_CDC_CLK_TX_CLK_EN_B2_CTL);
2340 }
2341
2342 if (!(tx_state & (1 << shift))) {
2343 tx_fs_reg = TABLA_A_CDC_TX1_CLK_FS_CTL
2344 + (BITS_PER_REG*(path-1));
2345 snd_soc_update_bits(codec, tx_fs_reg,
2346 0x03, tx_fs_rate);
2347 }
2348 }
Santosh Mardie15e2302011-11-15 10:39:23 +05302349 if (tabla->intf_type == TABLA_INTERFACE_TYPE_I2C) {
2350 switch (params_format(params)) {
2351 case SNDRV_PCM_FORMAT_S16_LE:
2352 snd_soc_update_bits(codec,
2353 TABLA_A_CDC_CLK_TX_I2S_CTL,
2354 0x20, 0x20);
2355 break;
2356 case SNDRV_PCM_FORMAT_S32_LE:
2357 snd_soc_update_bits(codec,
2358 TABLA_A_CDC_CLK_TX_I2S_CTL,
2359 0x20, 0x00);
2360 break;
2361 default:
2362 pr_err("invalid format\n");
2363 break;
2364 }
2365 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_TX_I2S_CTL,
2366 0x03, tx_fs_rate);
2367 }
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07002368 }
2369
2370 /**
2371 * TODO: Need to handle case where same RX chain takes 2 or more inputs
2372 * with varying sample rates
2373 */
2374
2375 /**
2376 * If current dai is a rx dai, set sample rate to
2377 * all the rx paths that are currently not active
2378 */
2379 if (dai->id == TABLA_RX_DAI_ID) {
2380
2381 rx_state = snd_soc_read(codec,
2382 TABLA_A_CDC_CLK_RX_B1_CTL);
2383
2384 for (path = 1, shift = 0;
2385 path <= NUM_INTERPOLATORS; path++, shift++) {
2386
2387 if (!(rx_state & (1 << shift))) {
2388 rx_fs_reg = TABLA_A_CDC_RX1_B5_CTL
2389 + (BITS_PER_REG*(path-1));
2390 snd_soc_update_bits(codec, rx_fs_reg,
2391 0xE0, rx_fs_rate);
2392 }
2393 }
Santosh Mardie15e2302011-11-15 10:39:23 +05302394 if (tabla->intf_type == TABLA_INTERFACE_TYPE_I2C) {
2395 switch (params_format(params)) {
2396 case SNDRV_PCM_FORMAT_S16_LE:
2397 snd_soc_update_bits(codec,
2398 TABLA_A_CDC_CLK_RX_I2S_CTL,
2399 0x20, 0x20);
2400 break;
2401 case SNDRV_PCM_FORMAT_S32_LE:
2402 snd_soc_update_bits(codec,
2403 TABLA_A_CDC_CLK_RX_I2S_CTL,
2404 0x20, 0x00);
2405 break;
2406 default:
2407 pr_err("invalid format\n");
2408 break;
2409 }
2410 snd_soc_update_bits(codec, TABLA_A_CDC_CLK_RX_I2S_CTL,
2411 0x03, (rx_fs_rate >> 0x05));
2412 }
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07002413 }
2414
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002415 return 0;
2416}
2417
2418static struct snd_soc_dai_ops tabla_dai_ops = {
2419 .startup = tabla_startup,
2420 .shutdown = tabla_shutdown,
2421 .hw_params = tabla_hw_params,
2422 .set_sysclk = tabla_set_dai_sysclk,
2423 .set_fmt = tabla_set_dai_fmt,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002424};
2425
2426static struct snd_soc_dai_driver tabla_dai[] = {
2427 {
2428 .name = "tabla_rx1",
2429 .id = 1,
2430 .playback = {
2431 .stream_name = "AIF1 Playback",
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07002432 .rates = WCD9310_RATES,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002433 .formats = TABLA_FORMATS,
2434 .rate_max = 48000,
2435 .rate_min = 8000,
2436 .channels_min = 1,
2437 .channels_max = 2,
2438 },
2439 .ops = &tabla_dai_ops,
2440 },
2441 {
2442 .name = "tabla_tx1",
2443 .id = 2,
2444 .capture = {
2445 .stream_name = "AIF1 Capture",
Bhalchandra Gajare9a901fd2011-08-01 10:07:15 -07002446 .rates = WCD9310_RATES,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002447 .formats = TABLA_FORMATS,
2448 .rate_max = 48000,
2449 .rate_min = 8000,
2450 .channels_min = 1,
2451 .channels_max = 2,
2452 },
2453 .ops = &tabla_dai_ops,
2454 },
2455};
Santosh Mardie15e2302011-11-15 10:39:23 +05302456
2457static struct snd_soc_dai_driver tabla_i2s_dai[] = {
2458 {
2459 .name = "tabla_i2s_rx1",
2460 .id = 1,
2461 .playback = {
2462 .stream_name = "AIF1 Playback",
2463 .rates = WCD9310_RATES,
2464 .formats = TABLA_FORMATS,
2465 .rate_max = 48000,
2466 .rate_min = 8000,
2467 .channels_min = 1,
2468 .channels_max = 4,
2469 },
2470 .ops = &tabla_dai_ops,
2471 },
2472 {
2473 .name = "tabla_i2s_tx1",
2474 .id = 2,
2475 .capture = {
2476 .stream_name = "AIF1 Capture",
2477 .rates = WCD9310_RATES,
2478 .formats = TABLA_FORMATS,
2479 .rate_max = 48000,
2480 .rate_min = 8000,
2481 .channels_min = 1,
2482 .channels_max = 4,
2483 },
2484 .ops = &tabla_dai_ops,
2485 },
2486};
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002487static short tabla_codec_read_sta_result(struct snd_soc_codec *codec)
Bradley Rubincb1e2732011-06-23 16:49:20 -07002488{
2489 u8 bias_msb, bias_lsb;
2490 short bias_value;
2491
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002492 bias_msb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B3_STATUS);
2493 bias_lsb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B2_STATUS);
2494 bias_value = (bias_msb << 8) | bias_lsb;
2495 return bias_value;
2496}
2497
2498static short tabla_codec_read_dce_result(struct snd_soc_codec *codec)
2499{
2500 u8 bias_msb, bias_lsb;
2501 short bias_value;
2502
2503 bias_msb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B5_STATUS);
2504 bias_lsb = snd_soc_read(codec, TABLA_A_CDC_MBHC_B4_STATUS);
2505 bias_value = (bias_msb << 8) | bias_lsb;
2506 return bias_value;
2507}
2508
2509static short tabla_codec_measure_micbias_voltage(struct snd_soc_codec *codec,
2510 int dce)
2511{
2512 short bias_value;
2513
Bradley Rubincb1e2732011-06-23 16:49:20 -07002514 if (dce) {
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002515 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2516 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x4);
2517 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x0);
2518 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x4);
2519 usleep_range(60000, 60000);
2520 bias_value = tabla_codec_read_dce_result(codec);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002521 } else {
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002522 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002523 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x2);
2524 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x0);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002525 usleep_range(5000, 5000);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002526 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x2);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002527 usleep_range(50, 50);
2528 bias_value = tabla_codec_read_sta_result(codec);
2529 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2530 snd_soc_write(codec, TABLA_A_CDC_MBHC_EN_CTL, 0x0);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002531 }
2532
Bradley Rubincb1e2732011-06-23 16:49:20 -07002533 pr_debug("read microphone bias value %x\n", bias_value);
2534 return bias_value;
2535}
2536
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002537static short tabla_codec_setup_hs_polling(struct snd_soc_codec *codec)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002538{
2539 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2540 struct tabla_mbhc_calibration *calibration = tabla->calibration;
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002541 short bias_value;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002542
2543 if (!calibration) {
2544 pr_err("Error, no tabla calibration\n");
Bradley Rubincb1e2732011-06-23 16:49:20 -07002545 return -ENODEV;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002546 }
2547
2548 tabla->mbhc_polling_active = true;
2549
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002550 if (!tabla->mclk_enabled) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002551 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_MBHC_MODE);
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002552 tabla_enable_rx_bias(codec, 1);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002553 tabla_codec_enable_clock_block(codec, 1);
2554 }
2555
2556 snd_soc_update_bits(codec, TABLA_A_CLK_BUFF_EN1, 0x05, 0x01);
2557
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002558 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS, 0xE0, 0xE0);
2559
Patrick Lai3043fba2011-08-01 14:15:57 -07002560
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002561 snd_soc_update_bits(codec,
2562 tabla->mbhc_bias_regs.cfilt_ctl, 0x70, 0x00);
Patrick Lai3043fba2011-08-01 14:15:57 -07002563
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002564 snd_soc_update_bits(codec,
2565 tabla->mbhc_bias_regs.ctl_reg, 0x1F, 0x16);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002566
2567 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x2, 0x2);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002568 snd_soc_write(codec, TABLA_A_MBHC_SCALING_MUX_1, 0x84);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002569
2570 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_EN, 0x80, 0x80);
2571 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_EN, 0x1F, 0x1C);
2572 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_TEST_CTL, 0x40, 0x40);
2573
2574 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_EN, 0x80, 0x00);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002575 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2576 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x00);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002577
Bradley Rubincb1e2732011-06-23 16:49:20 -07002578 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL, 0x6, 0x6);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002579 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x8, 0x8);
2580
Bradley Rubincb1e2732011-06-23 16:49:20 -07002581 tabla_codec_calibrate_hs_polling(codec);
2582
2583 bias_value = tabla_codec_measure_micbias_voltage(codec, 0);
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002584 snd_soc_update_bits(codec,
2585 tabla->mbhc_bias_regs.cfilt_ctl, 0x40, 0x40);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002586 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x13, 0x00);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002587
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002588 return bias_value;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002589}
2590
2591static int tabla_codec_enable_hs_detect(struct snd_soc_codec *codec,
2592 int insertion)
2593{
2594 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2595 struct tabla_mbhc_calibration *calibration = tabla->calibration;
2596 int central_bias_enabled = 0;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002597
2598 if (!calibration) {
2599 pr_err("Error, no tabla calibration\n");
2600 return -EINVAL;
2601 }
2602
2603 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x1, 0);
2604
Bhalchandra Gajare7fc72332011-10-13 19:01:55 -07002605 if (insertion) {
2606 /* Make sure mic bias and Mic line schmitt trigger
2607 * are turned OFF
2608 */
2609 snd_soc_update_bits(codec, tabla->mbhc_bias_regs.ctl_reg,
2610 0x81, 0x01);
2611 snd_soc_update_bits(codec, tabla->mbhc_bias_regs.mbhc_reg,
2612 0x90, 0x00);
2613
2614 /* Enable HPH Schmitt Trigger */
2615 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x13, 0x13);
2616 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x0C,
2617 calibration->hph_current << 2);
2618
2619 /* Turn off HPH PAs during insertion detection to avoid false
2620 * insertion interrupts
2621 */
2622 if (tabla->mbhc_micbias_switched)
2623 tabla_codec_switch_micbias(codec, 0);
2624 snd_soc_update_bits(codec, TABLA_A_RX_HPH_CNP_EN, 0x30, 0x00);
2625
2626 /* setup for insetion detection */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002627 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x2, 0);
Bhalchandra Gajare7fc72332011-10-13 19:01:55 -07002628 } else {
2629 /* Make sure the HPH schmitt trigger is OFF */
2630 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x12, 0x00);
2631
2632 /* enable the mic line schmitt trigger */
2633 snd_soc_update_bits(codec, tabla->mbhc_bias_regs.mbhc_reg, 0x60,
2634 calibration->mic_current << 5);
2635 snd_soc_update_bits(codec, tabla->mbhc_bias_regs.mbhc_reg,
2636 0x80, 0x80);
2637 usleep_range(calibration->mic_pid, calibration->mic_pid);
2638 snd_soc_update_bits(codec, tabla->mbhc_bias_regs.mbhc_reg,
2639 0x10, 0x10);
2640
2641 /* Setup for low power removal detection */
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002642 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x2, 0x2);
Bhalchandra Gajare7fc72332011-10-13 19:01:55 -07002643 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002644
2645 if (snd_soc_read(codec, TABLA_A_CDC_MBHC_B1_CTL) & 0x4) {
2646 if (!(tabla->clock_active)) {
2647 tabla_codec_enable_config_mode(codec, 1);
2648 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL,
Bradley Rubincb1e2732011-06-23 16:49:20 -07002649 0x06, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002650 usleep_range(calibration->shutdown_plug_removal,
2651 calibration->shutdown_plug_removal);
2652 tabla_codec_enable_config_mode(codec, 0);
2653 } else
2654 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL,
Bradley Rubincb1e2732011-06-23 16:49:20 -07002655 0x06, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002656 }
2657
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002658 snd_soc_update_bits(codec, tabla->mbhc_bias_regs.int_rbias, 0x80, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002659
2660 /* If central bandgap disabled */
2661 if (!(snd_soc_read(codec, TABLA_A_PIN_CTL_OE1) & 1)) {
2662 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE1, 0x3, 0x3);
2663 usleep_range(calibration->bg_fast_settle,
2664 calibration->bg_fast_settle);
2665 central_bias_enabled = 1;
2666 }
2667
2668 /* If LDO_H disabled */
2669 if (snd_soc_read(codec, TABLA_A_PIN_CTL_OE0) & 0x80) {
2670 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE0, 0x10, 0);
2671 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE0, 0x80, 0x80);
2672 usleep_range(calibration->tldoh, calibration->tldoh);
2673 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE0, 0x80, 0);
2674
2675 if (central_bias_enabled)
2676 snd_soc_update_bits(codec, TABLA_A_PIN_CTL_OE1, 0x1, 0);
2677 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002678
2679 snd_soc_update_bits(codec, TABLA_A_MICB_4_MBHC, 0x3, calibration->bias);
2680
2681 tabla_enable_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION);
2682 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x1, 0x1);
2683 return 0;
2684}
2685
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002686static void btn0_lpress_fn(struct work_struct *work)
2687{
2688 struct delayed_work *delayed_work;
2689 struct tabla_priv *tabla;
2690
2691 pr_debug("%s:\n", __func__);
2692
2693 delayed_work = to_delayed_work(work);
2694 tabla = container_of(delayed_work, struct tabla_priv, btn0_dwork);
2695
2696 if (tabla) {
2697 if (tabla->button_jack) {
2698 pr_debug("%s: Reporting long button press event\n",
2699 __func__);
2700 snd_soc_jack_report(tabla->button_jack, SND_JACK_BTN_0,
2701 SND_JACK_BTN_0);
2702 }
2703 } else {
2704 pr_err("%s: Bad tabla private data\n", __func__);
2705 }
2706
2707}
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07002708
Bradley Rubincb1e2732011-06-23 16:49:20 -07002709int tabla_hs_detect(struct snd_soc_codec *codec,
2710 struct snd_soc_jack *headset_jack, struct snd_soc_jack *button_jack,
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002711 struct tabla_mbhc_calibration *calibration)
2712{
2713 struct tabla_priv *tabla;
Patrick Lai49efeac2011-11-03 11:01:12 -07002714 int rc;
2715
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002716 if (!codec || !calibration) {
2717 pr_err("Error: no codec or calibration\n");
2718 return -EINVAL;
2719 }
2720 tabla = snd_soc_codec_get_drvdata(codec);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002721 tabla->headset_jack = headset_jack;
2722 tabla->button_jack = button_jack;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002723 tabla->calibration = calibration;
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002724 tabla_get_mbhc_micbias_regs(codec, &tabla->mbhc_bias_regs);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002725
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002726 INIT_DELAYED_WORK(&tabla->btn0_dwork, btn0_lpress_fn);
Patrick Lai49efeac2011-11-03 11:01:12 -07002727 INIT_WORK(&tabla->hphlocp_work, hphlocp_off_report);
2728 INIT_WORK(&tabla->hphrocp_work, hphrocp_off_report);
2729 rc = tabla_codec_enable_hs_detect(codec, 1);
2730
2731 if (!IS_ERR_VALUE(rc)) {
2732 snd_soc_update_bits(codec, TABLA_A_RX_HPH_OCP_CTL, 0x10,
2733 0x10);
2734 tabla_enable_irq(codec->control_data,
2735 TABLA_IRQ_HPH_PA_OCPL_FAULT);
2736 tabla_enable_irq(codec->control_data,
2737 TABLA_IRQ_HPH_PA_OCPR_FAULT);
2738 }
2739
2740 return rc;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002741}
2742EXPORT_SYMBOL_GPL(tabla_hs_detect);
2743
Bradley Rubincb1e2732011-06-23 16:49:20 -07002744static irqreturn_t tabla_dce_handler(int irq, void *data)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002745{
2746 struct tabla_priv *priv = data;
2747 struct snd_soc_codec *codec = priv->codec;
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002748 short bias_value;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002749
2750 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
2751 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
2752
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002753 bias_value = tabla_codec_read_dce_result(codec);
Bhalchandra Gajare30cf4842011-10-17 18:12:52 -07002754 pr_debug("%s: button press interrupt, bias value(DCE Read)=%d\n",
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002755 __func__, bias_value);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07002756
Bhalchandra Gajare30cf4842011-10-17 18:12:52 -07002757 bias_value = tabla_codec_read_sta_result(codec);
2758 pr_debug("%s: button press interrupt, bias value(STA Read)=%d\n",
2759 __func__, bias_value);
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002760 /*
2761 * TODO: If button pressed is not button 0,
2762 * report the button press event immediately.
2763 */
2764 priv->buttons_pressed |= SND_JACK_BTN_0;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002765
Bradley Rubin688c66a2011-08-16 12:25:13 -07002766 msleep(100);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002767
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002768 schedule_delayed_work(&priv->btn0_dwork, msecs_to_jiffies(400));
2769
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002770 return IRQ_HANDLED;
2771}
2772
Bradley Rubincb1e2732011-06-23 16:49:20 -07002773static irqreturn_t tabla_release_handler(int irq, void *data)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002774{
2775 struct tabla_priv *priv = data;
2776 struct snd_soc_codec *codec = priv->codec;
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002777 int ret, mic_voltage;
2778
Bradley Rubin4d09cf42011-08-17 17:59:16 -07002779 pr_debug("%s\n", __func__);
2780 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002781
Bhalchandra Gajare30cf4842011-10-17 18:12:52 -07002782 mic_voltage = tabla_codec_read_dce_result(codec);
2783 pr_debug("%s: Microphone Voltage on release(DCE Read) = %d\n",
2784 __func__, mic_voltage);
2785
Bradley Rubincb1e2732011-06-23 16:49:20 -07002786 if (priv->buttons_pressed & SND_JACK_BTN_0) {
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002787 ret = cancel_delayed_work(&priv->btn0_dwork);
2788
2789 if (ret == 0) {
2790
2791 pr_debug("%s: Reporting long button release event\n",
2792 __func__);
2793 if (priv->button_jack) {
2794 snd_soc_jack_report(priv->button_jack, 0,
2795 SND_JACK_BTN_0);
2796 }
2797
2798 } else {
2799
2800 mic_voltage =
2801 tabla_codec_measure_micbias_voltage(codec, 0);
Bhalchandra Gajare30cf4842011-10-17 18:12:52 -07002802 pr_debug("%s: Mic Voltage on release(new STA) = %d\n",
Bhalchandra Gajare0a792b12011-09-06 16:36:58 -07002803 __func__, mic_voltage);
2804
2805 if (mic_voltage < -2000 || mic_voltage > -670) {
2806 pr_debug("%s: Fake buttton press interrupt\n",
2807 __func__);
2808 } else {
2809
2810 if (priv->button_jack) {
2811 pr_debug("%s:reporting short button press and release\n",
2812 __func__);
2813
2814 snd_soc_jack_report(priv->button_jack,
2815 SND_JACK_BTN_0, SND_JACK_BTN_0);
2816 snd_soc_jack_report(priv->button_jack,
2817 0, SND_JACK_BTN_0);
2818 }
2819 }
2820 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002821
Bradley Rubincb1e2732011-06-23 16:49:20 -07002822 priv->buttons_pressed &= ~SND_JACK_BTN_0;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002823 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002824
Bradley Rubin688c66a2011-08-16 12:25:13 -07002825 tabla_codec_start_hs_polling(codec);
2826
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002827 return IRQ_HANDLED;
2828}
2829
Bradley Rubincb1e2732011-06-23 16:49:20 -07002830static void tabla_codec_shutdown_hs_removal_detect(struct snd_soc_codec *codec)
2831{
2832 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
2833 struct tabla_mbhc_calibration *calibration = tabla->calibration;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002834
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002835 if (!tabla->mclk_enabled && !tabla->mbhc_polling_active)
Bradley Rubincb1e2732011-06-23 16:49:20 -07002836 tabla_codec_enable_config_mode(codec, 1);
2837
2838 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0x2, 0x2);
2839 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_B1_CTL, 0x6, 0x0);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002840
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002841 snd_soc_update_bits(codec,
2842 tabla->mbhc_bias_regs.mbhc_reg, 0x80, 0x00);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002843 usleep_range(calibration->shutdown_plug_removal,
2844 calibration->shutdown_plug_removal);
2845
2846 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_CLK_CTL, 0xA, 0x8);
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002847 if (!tabla->mclk_enabled && !tabla->mbhc_polling_active)
Bradley Rubincb1e2732011-06-23 16:49:20 -07002848 tabla_codec_enable_config_mode(codec, 0);
2849
2850 snd_soc_write(codec, TABLA_A_MBHC_SCALING_MUX_1, 0x00);
2851}
2852
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002853static void tabla_codec_shutdown_hs_polling(struct snd_soc_codec *codec)
2854{
2855 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002856
2857 tabla_codec_shutdown_hs_removal_detect(codec);
2858
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07002859 if (!tabla->mclk_enabled) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002860 snd_soc_update_bits(codec, TABLA_A_TX_COM_BIAS, 0xE0, 0x00);
2861 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_AUDIO_MODE);
2862 tabla_codec_enable_clock_block(codec, 0);
2863 }
2864
2865 tabla->mbhc_polling_active = false;
2866}
2867
Patrick Lai49efeac2011-11-03 11:01:12 -07002868static irqreturn_t tabla_hphl_ocp_irq(int irq, void *data)
2869{
2870 struct tabla_priv *tabla = data;
2871 struct snd_soc_codec *codec;
2872
2873 pr_info("%s: received HPHL OCP irq\n", __func__);
2874
2875 if (tabla) {
2876 codec = tabla->codec;
2877 tabla_disable_irq(codec->control_data,
2878 TABLA_IRQ_HPH_PA_OCPL_FAULT);
2879 tabla->hph_status |= SND_JACK_OC_HPHL;
2880 if (tabla->headset_jack) {
2881 snd_soc_jack_report(tabla->headset_jack,
2882 tabla->hph_status, TABLA_JACK_MASK);
2883 }
2884 } else {
2885 pr_err("%s: Bad tabla private data\n", __func__);
2886 }
2887
2888 return IRQ_HANDLED;
2889}
2890
2891static irqreturn_t tabla_hphr_ocp_irq(int irq, void *data)
2892{
2893 struct tabla_priv *tabla = data;
2894 struct snd_soc_codec *codec;
2895
2896 pr_info("%s: received HPHR OCP irq\n", __func__);
2897
2898 if (tabla) {
2899 codec = tabla->codec;
2900 tabla_disable_irq(codec->control_data,
2901 TABLA_IRQ_HPH_PA_OCPR_FAULT);
2902 tabla->hph_status |= SND_JACK_OC_HPHR;
2903 if (tabla->headset_jack) {
2904 snd_soc_jack_report(tabla->headset_jack,
2905 tabla->hph_status, TABLA_JACK_MASK);
2906 }
2907 } else {
2908 pr_err("%s: Bad tabla private data\n", __func__);
2909 }
2910
2911 return IRQ_HANDLED;
2912}
2913
Bradley Rubincb1e2732011-06-23 16:49:20 -07002914static irqreturn_t tabla_hs_insert_irq(int irq, void *data)
2915{
2916 struct tabla_priv *priv = data;
2917 struct snd_soc_codec *codec = priv->codec;
Bradley Rubin355611a2011-08-24 14:01:18 -07002918 int ldo_h_on, micb_cfilt_on;
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002919 short mic_voltage;
2920 short threshold_no_mic = 0xF7F6;
2921 short threshold_fake_insert = 0xFD30;
Bhalchandra Gajare7fc72332011-10-13 19:01:55 -07002922 u8 is_removal;
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002923
Bradley Rubincb1e2732011-06-23 16:49:20 -07002924
Bradley Rubin4d09cf42011-08-17 17:59:16 -07002925 pr_debug("%s\n", __func__);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002926 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION);
Bhalchandra Gajare7fc72332011-10-13 19:01:55 -07002927 is_removal = snd_soc_read(codec, TABLA_A_CDC_MBHC_INT_CTL) & 0x02;
2928 snd_soc_update_bits(codec, TABLA_A_CDC_MBHC_INT_CTL, 0x03, 0x00);
2929
2930 /* Turn off both HPH and MIC line schmitt triggers */
2931 snd_soc_update_bits(codec, priv->mbhc_bias_regs.mbhc_reg,
2932 0x90, 0x00);
2933 snd_soc_update_bits(codec, TABLA_A_MBHC_HPH, 0x13, 0x00);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002934
Bradley Rubin355611a2011-08-24 14:01:18 -07002935 ldo_h_on = snd_soc_read(codec, TABLA_A_LDO_H_MODE_1) & 0x80;
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002936 micb_cfilt_on = snd_soc_read(codec,
2937 priv->mbhc_bias_regs.cfilt_ctl) & 0x80;
Bradley Rubin355611a2011-08-24 14:01:18 -07002938
2939 if (!ldo_h_on)
2940 snd_soc_update_bits(codec, TABLA_A_LDO_H_MODE_1, 0x80, 0x80);
2941 if (!micb_cfilt_on)
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07002942 snd_soc_update_bits(codec, priv->mbhc_bias_regs.cfilt_ctl,
2943 0x80, 0x80);
Bradley Rubin355611a2011-08-24 14:01:18 -07002944
Bradley Rubincb1e2732011-06-23 16:49:20 -07002945 usleep_range(priv->calibration->setup_plug_removal_delay,
2946 priv->calibration->setup_plug_removal_delay);
2947
Bhalchandra Gajare7fc72332011-10-13 19:01:55 -07002948 if (!ldo_h_on)
2949 snd_soc_update_bits(codec, TABLA_A_LDO_H_MODE_1, 0x80, 0x0);
2950 if (!micb_cfilt_on)
2951 snd_soc_update_bits(codec, priv->mbhc_bias_regs.cfilt_ctl,
2952 0x80, 0x0);
2953
2954 if (is_removal) {
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07002955 /*
2956 * If headphone is removed while playback is in progress,
2957 * it is possible that micbias will be switched to VDDIO.
2958 */
2959 if (priv->mbhc_micbias_switched)
2960 tabla_codec_switch_micbias(codec, 0);
Patrick Lai49efeac2011-11-03 11:01:12 -07002961 priv->hph_status &= ~SND_JACK_HEADSET;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002962 if (priv->headset_jack) {
2963 pr_debug("%s: Reporting removal\n", __func__);
Patrick Lai49efeac2011-11-03 11:01:12 -07002964 snd_soc_jack_report(priv->headset_jack,
2965 priv->hph_status, TABLA_JACK_MASK);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002966 }
2967 tabla_codec_shutdown_hs_removal_detect(codec);
2968 tabla_codec_enable_hs_detect(codec, 1);
2969 return IRQ_HANDLED;
2970 }
2971
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002972 mic_voltage = tabla_codec_setup_hs_polling(codec);
Bradley Rubin355611a2011-08-24 14:01:18 -07002973
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002974 if (mic_voltage > threshold_fake_insert) {
2975 pr_debug("%s: Fake insertion interrupt, mic_voltage = %x\n",
2976 __func__, mic_voltage);
2977 tabla_codec_enable_hs_detect(codec, 1);
2978 } else if (mic_voltage < threshold_no_mic) {
2979 pr_debug("%s: Headphone Detected, mic_voltage = %x\n",
2980 __func__, mic_voltage);
Patrick Lai49efeac2011-11-03 11:01:12 -07002981 priv->hph_status |= SND_JACK_HEADPHONE;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002982 if (priv->headset_jack) {
2983 pr_debug("%s: Reporting insertion %d\n", __func__,
2984 SND_JACK_HEADPHONE);
2985 snd_soc_jack_report(priv->headset_jack,
Patrick Lai49efeac2011-11-03 11:01:12 -07002986 priv->hph_status, TABLA_JACK_MASK);
Bradley Rubincb1e2732011-06-23 16:49:20 -07002987 }
2988 tabla_codec_shutdown_hs_polling(codec);
2989 tabla_codec_enable_hs_detect(codec, 0);
Bhalchandra Gajare343cbb02011-09-07 18:58:19 -07002990
2991 } else {
2992 pr_debug("%s: Headset detected, mic_voltage = %x\n",
2993 __func__, mic_voltage);
Patrick Lai49efeac2011-11-03 11:01:12 -07002994 priv->hph_status |= SND_JACK_HEADSET;
Bradley Rubincb1e2732011-06-23 16:49:20 -07002995 if (priv->headset_jack) {
2996 pr_debug("%s: Reporting insertion %d\n", __func__,
2997 SND_JACK_HEADSET);
2998 snd_soc_jack_report(priv->headset_jack,
Patrick Lai49efeac2011-11-03 11:01:12 -07002999 priv->hph_status, TABLA_JACK_MASK);
Bradley Rubincb1e2732011-06-23 16:49:20 -07003000 }
3001 tabla_codec_start_hs_polling(codec);
3002 }
3003
3004 return IRQ_HANDLED;
3005}
3006
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003007static irqreturn_t tabla_hs_remove_irq(int irq, void *data)
3008{
3009 struct tabla_priv *priv = data;
3010 struct snd_soc_codec *codec = priv->codec;
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07003011 short bias_value;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003012
3013 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
3014 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
Bradley Rubin4d09cf42011-08-17 17:59:16 -07003015 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003016
3017 usleep_range(priv->calibration->shutdown_plug_removal,
3018 priv->calibration->shutdown_plug_removal);
3019
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07003020 bias_value = tabla_codec_measure_micbias_voltage(codec, 1);
3021 pr_debug("removal interrupt, bias value is %d\n", bias_value);
3022
3023 if (bias_value < -90) {
3024 pr_debug("False alarm, headset not actually removed\n");
3025 tabla_codec_start_hs_polling(codec);
3026 } else {
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07003027 /*
3028 * If this removal is not false, first check the micbias
3029 * switch status and switch it to LDOH if it is already
3030 * switched to VDDIO.
3031 */
3032 if (priv->mbhc_micbias_switched)
3033 tabla_codec_switch_micbias(codec, 0);
Patrick Lai49efeac2011-11-03 11:01:12 -07003034 priv->hph_status &= ~SND_JACK_HEADSET;
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07003035 if (priv->headset_jack) {
3036 pr_debug("%s: Reporting removal\n", __func__);
3037 snd_soc_jack_report(priv->headset_jack, 0,
Patrick Lai49efeac2011-11-03 11:01:12 -07003038 TABLA_JACK_MASK);
Bradley Rubin89ffd0a2011-07-21 16:04:06 -07003039 }
3040 tabla_codec_shutdown_hs_polling(codec);
3041
3042 tabla_codec_enable_hs_detect(codec, 1);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003043 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003044 return IRQ_HANDLED;
3045}
3046
3047static unsigned long slimbus_value;
3048
3049static irqreturn_t tabla_slimbus_irq(int irq, void *data)
3050{
3051 struct tabla_priv *priv = data;
3052 struct snd_soc_codec *codec = priv->codec;
3053 int i, j;
3054 u8 val;
3055
3056 for (i = 0; i < TABLA_SLIM_NUM_PORT_REG; i++) {
3057 slimbus_value = tabla_interface_reg_read(codec->control_data,
3058 TABLA_SLIM_PGD_PORT_INT_STATUS0 + i);
3059 for_each_set_bit(j, &slimbus_value, BITS_PER_BYTE) {
3060 val = tabla_interface_reg_read(codec->control_data,
3061 TABLA_SLIM_PGD_PORT_INT_SOURCE0 + i*8 + j);
3062 if (val & 0x1)
3063 pr_err_ratelimited("overflow error on port %x,"
3064 " value %x\n", i*8 + j, val);
3065 if (val & 0x2)
3066 pr_err_ratelimited("underflow error on port %x,"
3067 " value %x\n", i*8 + j, val);
3068 }
3069 tabla_interface_reg_write(codec->control_data,
3070 TABLA_SLIM_PGD_PORT_INT_CLR0 + i, 0xFF);
3071 }
3072
3073 return IRQ_HANDLED;
3074}
3075
Patrick Lai3043fba2011-08-01 14:15:57 -07003076
3077static int tabla_handle_pdata(struct tabla_priv *tabla)
3078{
3079 struct snd_soc_codec *codec = tabla->codec;
3080 struct tabla_pdata *pdata = tabla->pdata;
3081 int k1, k2, k3, rc = 0;
Santosh Mardi22920282011-10-26 02:38:40 +05303082 u8 leg_mode = pdata->amic_settings.legacy_mode;
3083 u8 txfe_bypass = pdata->amic_settings.txfe_enable;
3084 u8 txfe_buff = pdata->amic_settings.txfe_buff;
3085 u8 flag = pdata->amic_settings.use_pdata;
3086 u8 i = 0, j = 0;
3087 u8 val_txfe = 0, value = 0;
Patrick Lai3043fba2011-08-01 14:15:57 -07003088
3089 if (!pdata) {
3090 rc = -ENODEV;
3091 goto done;
3092 }
3093
3094 /* Make sure settings are correct */
3095 if ((pdata->micbias.ldoh_v > TABLA_LDOH_2P85_V) ||
3096 (pdata->micbias.bias1_cfilt_sel > TABLA_CFILT3_SEL) ||
3097 (pdata->micbias.bias2_cfilt_sel > TABLA_CFILT3_SEL) ||
3098 (pdata->micbias.bias3_cfilt_sel > TABLA_CFILT3_SEL) ||
3099 (pdata->micbias.bias4_cfilt_sel > TABLA_CFILT3_SEL)) {
3100 rc = -EINVAL;
3101 goto done;
3102 }
3103
3104 /* figure out k value */
3105 k1 = tabla_find_k_value(pdata->micbias.ldoh_v,
3106 pdata->micbias.cfilt1_mv);
3107 k2 = tabla_find_k_value(pdata->micbias.ldoh_v,
3108 pdata->micbias.cfilt2_mv);
3109 k3 = tabla_find_k_value(pdata->micbias.ldoh_v,
3110 pdata->micbias.cfilt3_mv);
3111
3112 if (IS_ERR_VALUE(k1) || IS_ERR_VALUE(k2) || IS_ERR_VALUE(k3)) {
3113 rc = -EINVAL;
3114 goto done;
3115 }
3116
3117 /* Set voltage level and always use LDO */
3118 snd_soc_update_bits(codec, TABLA_A_LDO_H_MODE_1, 0x0C,
3119 (pdata->micbias.ldoh_v << 2));
3120
3121 snd_soc_update_bits(codec, TABLA_A_MICB_CFILT_1_VAL, 0xFC,
3122 (k1 << 2));
3123 snd_soc_update_bits(codec, TABLA_A_MICB_CFILT_2_VAL, 0xFC,
3124 (k2 << 2));
3125 snd_soc_update_bits(codec, TABLA_A_MICB_CFILT_3_VAL, 0xFC,
3126 (k3 << 2));
3127
3128 snd_soc_update_bits(codec, TABLA_A_MICB_1_CTL, 0x60,
3129 (pdata->micbias.bias1_cfilt_sel << 5));
3130 snd_soc_update_bits(codec, TABLA_A_MICB_2_CTL, 0x60,
3131 (pdata->micbias.bias2_cfilt_sel << 5));
3132 snd_soc_update_bits(codec, TABLA_A_MICB_3_CTL, 0x60,
3133 (pdata->micbias.bias3_cfilt_sel << 5));
3134 snd_soc_update_bits(codec, TABLA_A_MICB_4_CTL, 0x60,
3135 (pdata->micbias.bias4_cfilt_sel << 5));
3136
Santosh Mardi22920282011-10-26 02:38:40 +05303137 for (i = 0; i < 6; j++, i += 2) {
3138 if (flag & (0x01 << i)) {
3139 value = (leg_mode & (0x01 << i)) ? 0x10 : 0x00;
3140 val_txfe = (txfe_bypass & (0x01 << i)) ? 0x20 : 0x00;
3141 val_txfe = val_txfe |
3142 ((txfe_buff & (0x01 << i)) ? 0x10 : 0x00);
3143 snd_soc_update_bits(codec, TABLA_A_TX_1_2_EN + j * 10,
3144 0x10, value);
3145 snd_soc_update_bits(codec,
3146 TABLA_A_TX_1_2_TEST_EN + j * 10,
3147 0x30, val_txfe);
3148 }
3149 if (flag & (0x01 << (i + 1))) {
3150 value = (leg_mode & (0x01 << (i + 1))) ? 0x01 : 0x00;
3151 val_txfe = (txfe_bypass &
3152 (0x01 << (i + 1))) ? 0x02 : 0x00;
3153 val_txfe |= (txfe_buff &
3154 (0x01 << (i + 1))) ? 0x01 : 0x00;
3155 snd_soc_update_bits(codec, TABLA_A_TX_1_2_EN + j * 10,
3156 0x01, value);
3157 snd_soc_update_bits(codec,
3158 TABLA_A_TX_1_2_TEST_EN + j * 10,
3159 0x03, val_txfe);
3160 }
3161 }
3162 if (flag & 0x40) {
3163 value = (leg_mode & 0x40) ? 0x10 : 0x00;
3164 value = value | ((txfe_bypass & 0x40) ? 0x02 : 0x00);
3165 value = value | ((txfe_buff & 0x40) ? 0x01 : 0x00);
3166 snd_soc_update_bits(codec, TABLA_A_TX_7_MBHC_EN,
3167 0x13, value);
3168 }
Patrick Lai49efeac2011-11-03 11:01:12 -07003169
3170 if (pdata->ocp.use_pdata) {
3171 /* not defined in CODEC specification */
3172 if (pdata->ocp.hph_ocp_limit == 1 ||
3173 pdata->ocp.hph_ocp_limit == 5) {
3174 rc = -EINVAL;
3175 goto done;
3176 }
3177 snd_soc_update_bits(codec, TABLA_A_RX_COM_OCP_CTL,
3178 0x0F, pdata->ocp.num_attempts);
3179 snd_soc_write(codec, TABLA_A_RX_COM_OCP_COUNT,
3180 ((pdata->ocp.run_time << 4) | pdata->ocp.wait_time));
3181 snd_soc_update_bits(codec, TABLA_A_RX_HPH_OCP_CTL,
3182 0xE0, (pdata->ocp.hph_ocp_limit << 5));
3183 }
Patrick Lai3043fba2011-08-01 14:15:57 -07003184done:
3185 return rc;
3186}
3187
Kiran Kandi1f6fd722011-08-11 10:36:11 -07003188static const struct tabla_reg_mask_val tabla_1_1_reg_defaults[] = {
3189
3190 /* Tabla 1.1 MICBIAS changes */
3191 TABLA_REG_VAL(TABLA_A_MICB_1_INT_RBIAS, 0x24),
3192 TABLA_REG_VAL(TABLA_A_MICB_2_INT_RBIAS, 0x24),
3193 TABLA_REG_VAL(TABLA_A_MICB_3_INT_RBIAS, 0x24),
3194 TABLA_REG_VAL(TABLA_A_MICB_4_INT_RBIAS, 0x24),
3195
3196 /* Tabla 1.1 HPH changes */
3197 TABLA_REG_VAL(TABLA_A_RX_HPH_BIAS_PA, 0x57),
3198 TABLA_REG_VAL(TABLA_A_RX_HPH_BIAS_LDO, 0x56),
3199
3200 /* Tabla 1.1 EAR PA changes */
3201 TABLA_REG_VAL(TABLA_A_RX_EAR_BIAS_PA, 0xA6),
3202 TABLA_REG_VAL(TABLA_A_RX_EAR_GAIN, 0x02),
3203 TABLA_REG_VAL(TABLA_A_RX_EAR_VCM, 0x03),
3204
3205 /* Tabla 1.1 Lineout_5 Changes */
3206 TABLA_REG_VAL(TABLA_A_RX_LINE_5_GAIN, 0x10),
3207
3208 /* Tabla 1.1 RX Changes */
3209 TABLA_REG_VAL(TABLA_A_CDC_RX1_B5_CTL, 0x78),
3210 TABLA_REG_VAL(TABLA_A_CDC_RX2_B5_CTL, 0x78),
3211 TABLA_REG_VAL(TABLA_A_CDC_RX3_B5_CTL, 0x78),
3212 TABLA_REG_VAL(TABLA_A_CDC_RX4_B5_CTL, 0x78),
3213 TABLA_REG_VAL(TABLA_A_CDC_RX5_B5_CTL, 0x78),
3214 TABLA_REG_VAL(TABLA_A_CDC_RX6_B5_CTL, 0x78),
3215 TABLA_REG_VAL(TABLA_A_CDC_RX7_B5_CTL, 0x78),
3216
3217 /* Tabla 1.1 RX1 and RX2 Changes */
3218 TABLA_REG_VAL(TABLA_A_CDC_RX1_B6_CTL, 0xA0),
3219 TABLA_REG_VAL(TABLA_A_CDC_RX2_B6_CTL, 0xA0),
3220
3221 /* Tabla 1.1 RX3 to RX7 Changes */
3222 TABLA_REG_VAL(TABLA_A_CDC_RX3_B6_CTL, 0x80),
3223 TABLA_REG_VAL(TABLA_A_CDC_RX4_B6_CTL, 0x80),
3224 TABLA_REG_VAL(TABLA_A_CDC_RX5_B6_CTL, 0x80),
3225 TABLA_REG_VAL(TABLA_A_CDC_RX6_B6_CTL, 0x80),
3226 TABLA_REG_VAL(TABLA_A_CDC_RX7_B6_CTL, 0x80),
3227
3228 /* Tabla 1.1 CLASSG Changes */
3229 TABLA_REG_VAL(TABLA_A_CDC_CLSG_FREQ_THRESH_B3_CTL, 0x1B),
3230};
3231
3232static const struct tabla_reg_mask_val tabla_2_0_reg_defaults[] = {
3233
3234 /* Tabla 2.0 MICBIAS changes */
3235 TABLA_REG_VAL(TABLA_A_MICB_2_MBHC, 0x02),
3236};
3237
3238static void tabla_update_reg_defaults(struct snd_soc_codec *codec)
3239{
3240 u32 i;
3241
3242 for (i = 0; i < ARRAY_SIZE(tabla_1_1_reg_defaults); i++)
3243 snd_soc_write(codec, tabla_1_1_reg_defaults[i].reg,
3244 tabla_1_1_reg_defaults[i].val);
3245
3246 for (i = 0; i < ARRAY_SIZE(tabla_2_0_reg_defaults); i++)
3247 snd_soc_write(codec, tabla_2_0_reg_defaults[i].reg,
3248 tabla_2_0_reg_defaults[i].val);
3249}
3250
3251static const struct tabla_reg_mask_val tabla_codec_reg_init_val[] = {
Patrick Lai49efeac2011-11-03 11:01:12 -07003252 /* Initialize current threshold to 350MA */
3253 {TABLA_A_RX_HPH_OCP_CTL, 0xE0, 0x60},
Kiran Kandi1f6fd722011-08-11 10:36:11 -07003254
Santosh Mardi32171012011-10-28 23:32:06 +05303255 {TABLA_A_QFUSE_CTL, 0xFF, 0x03},
3256
Kiran Kandi1f6fd722011-08-11 10:36:11 -07003257 /* Initialize gain registers to use register gain */
3258 {TABLA_A_RX_HPH_L_GAIN, 0x10, 0x10},
3259 {TABLA_A_RX_HPH_R_GAIN, 0x10, 0x10},
3260 {TABLA_A_RX_LINE_1_GAIN, 0x10, 0x10},
3261 {TABLA_A_RX_LINE_2_GAIN, 0x10, 0x10},
3262 {TABLA_A_RX_LINE_3_GAIN, 0x10, 0x10},
3263 {TABLA_A_RX_LINE_4_GAIN, 0x10, 0x10},
3264
3265 /* Initialize mic biases to differential mode */
3266 {TABLA_A_MICB_1_INT_RBIAS, 0x24, 0x24},
3267 {TABLA_A_MICB_2_INT_RBIAS, 0x24, 0x24},
3268 {TABLA_A_MICB_3_INT_RBIAS, 0x24, 0x24},
3269 {TABLA_A_MICB_4_INT_RBIAS, 0x24, 0x24},
3270
3271 {TABLA_A_CDC_CONN_CLSG_CTL, 0x3C, 0x14},
3272
3273 /* Use 16 bit sample size for TX1 to TX6 */
3274 {TABLA_A_CDC_CONN_TX_SB_B1_CTL, 0x30, 0x20},
3275 {TABLA_A_CDC_CONN_TX_SB_B2_CTL, 0x30, 0x20},
3276 {TABLA_A_CDC_CONN_TX_SB_B3_CTL, 0x30, 0x20},
3277 {TABLA_A_CDC_CONN_TX_SB_B4_CTL, 0x30, 0x20},
3278 {TABLA_A_CDC_CONN_TX_SB_B5_CTL, 0x30, 0x20},
3279 {TABLA_A_CDC_CONN_TX_SB_B6_CTL, 0x30, 0x20},
3280
3281 /* Use 16 bit sample size for TX7 to TX10 */
3282 {TABLA_A_CDC_CONN_TX_SB_B7_CTL, 0x60, 0x40},
3283 {TABLA_A_CDC_CONN_TX_SB_B8_CTL, 0x60, 0x40},
3284 {TABLA_A_CDC_CONN_TX_SB_B9_CTL, 0x60, 0x40},
3285 {TABLA_A_CDC_CONN_TX_SB_B10_CTL, 0x60, 0x40},
3286
3287 /* Use 16 bit sample size for RX */
3288 {TABLA_A_CDC_CONN_RX_SB_B1_CTL, 0xFF, 0xAA},
3289 {TABLA_A_CDC_CONN_RX_SB_B2_CTL, 0xFF, 0xAA},
3290
3291 /*enable HPF filter for TX paths */
3292 {TABLA_A_CDC_TX1_MUX_CTL, 0x8, 0x0},
3293 {TABLA_A_CDC_TX2_MUX_CTL, 0x8, 0x0},
3294 {TABLA_A_CDC_TX3_MUX_CTL, 0x8, 0x0},
3295 {TABLA_A_CDC_TX4_MUX_CTL, 0x8, 0x0},
3296 {TABLA_A_CDC_TX5_MUX_CTL, 0x8, 0x0},
3297 {TABLA_A_CDC_TX6_MUX_CTL, 0x8, 0x0},
3298 {TABLA_A_CDC_TX7_MUX_CTL, 0x8, 0x0},
3299 {TABLA_A_CDC_TX8_MUX_CTL, 0x8, 0x0},
3300 {TABLA_A_CDC_TX9_MUX_CTL, 0x8, 0x0},
3301 {TABLA_A_CDC_TX10_MUX_CTL, 0x8, 0x0},
3302};
3303
3304static void tabla_codec_init_reg(struct snd_soc_codec *codec)
3305{
3306 u32 i;
3307
3308 for (i = 0; i < ARRAY_SIZE(tabla_codec_reg_init_val); i++)
3309 snd_soc_update_bits(codec, tabla_codec_reg_init_val[i].reg,
3310 tabla_codec_reg_init_val[i].mask,
3311 tabla_codec_reg_init_val[i].val);
3312}
3313
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003314static int tabla_codec_probe(struct snd_soc_codec *codec)
3315{
3316 struct tabla *control;
3317 struct tabla_priv *tabla;
3318 struct snd_soc_dapm_context *dapm = &codec->dapm;
3319 int ret = 0;
3320 int i;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003321
3322 codec->control_data = dev_get_drvdata(codec->dev->parent);
3323 control = codec->control_data;
3324
3325 tabla = kzalloc(sizeof(struct tabla_priv), GFP_KERNEL);
3326 if (!tabla) {
3327 dev_err(codec->dev, "Failed to allocate private data\n");
3328 return -ENOMEM;
3329 }
3330
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07003331 /* Make sure mbhc micbias register addresses are zeroed out */
3332 memset(&tabla->mbhc_bias_regs, 0,
3333 sizeof(struct mbhc_micbias_regs));
Bhalchandra Gajared9ebb6c2011-10-03 19:54:41 -07003334 tabla->cfilt_k_value = 0;
3335 tabla->mbhc_micbias_switched = false;
Bhalchandra Gajare02d90cd2011-09-30 16:14:00 -07003336
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003337 snd_soc_codec_set_drvdata(codec, tabla);
3338
Kiran Kandi6fae8bf2011-08-15 10:36:42 -07003339 tabla->mclk_enabled = false;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003340 tabla->bandgap_type = TABLA_BANDGAP_OFF;
3341 tabla->clock_active = false;
3342 tabla->config_mode_active = false;
3343 tabla->mbhc_polling_active = false;
Bradley Rubincb3950a2011-08-18 13:07:26 -07003344 tabla->no_mic_headset_override = false;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003345 tabla->codec = codec;
Patrick Lai3043fba2011-08-01 14:15:57 -07003346 tabla->pdata = dev_get_platdata(codec->dev->parent);
Santosh Mardie15e2302011-11-15 10:39:23 +05303347 tabla->intf_type = tabla_get_intf_type();
Patrick Lai3043fba2011-08-01 14:15:57 -07003348
Santosh Mardi22920282011-10-26 02:38:40 +05303349 tabla_update_reg_defaults(codec);
3350 tabla_codec_init_reg(codec);
Patrick Lai3043fba2011-08-01 14:15:57 -07003351
Santosh Mardi22920282011-10-26 02:38:40 +05303352 ret = tabla_handle_pdata(tabla);
Patrick Lai3043fba2011-08-01 14:15:57 -07003353 if (IS_ERR_VALUE(ret)) {
3354 pr_err("%s: bad pdata\n", __func__);
3355 goto err_pdata;
3356 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003357
3358 /* TODO only enable bandgap when necessary in order to save power */
3359 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_AUDIO_MODE);
3360 tabla_codec_enable_clock_block(codec, 0);
3361
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003362 snd_soc_add_controls(codec, tabla_snd_controls,
3363 ARRAY_SIZE(tabla_snd_controls));
3364 snd_soc_dapm_new_controls(dapm, tabla_dapm_widgets,
3365 ARRAY_SIZE(tabla_dapm_widgets));
Santosh Mardie15e2302011-11-15 10:39:23 +05303366 if (tabla->intf_type == TABLA_INTERFACE_TYPE_I2C) {
3367 snd_soc_dapm_new_controls(dapm, tabla_dapm_i2s_widgets,
3368 ARRAY_SIZE(tabla_dapm_i2s_widgets));
3369 snd_soc_dapm_add_routes(dapm, audio_i2s_map,
3370 ARRAY_SIZE(audio_i2s_map));
3371 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003372 snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
3373 snd_soc_dapm_sync(dapm);
3374
3375 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION,
3376 tabla_hs_insert_irq, "Headset insert detect", tabla);
3377 if (ret) {
3378 pr_err("%s: Failed to request irq %d\n", __func__,
3379 TABLA_IRQ_MBHC_INSERTION);
3380 goto err_insert_irq;
3381 }
3382 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION);
3383
3384 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL,
3385 tabla_hs_remove_irq, "Headset remove detect", tabla);
3386 if (ret) {
3387 pr_err("%s: Failed to request irq %d\n", __func__,
3388 TABLA_IRQ_MBHC_REMOVAL);
3389 goto err_remove_irq;
3390 }
3391 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL);
3392
3393 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL,
Bradley Rubincb1e2732011-06-23 16:49:20 -07003394 tabla_dce_handler, "DC Estimation detect", tabla);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003395 if (ret) {
3396 pr_err("%s: Failed to request irq %d\n", __func__,
3397 TABLA_IRQ_MBHC_POTENTIAL);
3398 goto err_potential_irq;
3399 }
3400 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL);
3401
Bradley Rubincb1e2732011-06-23 16:49:20 -07003402 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE,
3403 tabla_release_handler, "Button Release detect", tabla);
3404 if (ret) {
3405 pr_err("%s: Failed to request irq %d\n", __func__,
3406 TABLA_IRQ_MBHC_RELEASE);
3407 goto err_release_irq;
3408 }
Bradley Rubin4d09cf42011-08-17 17:59:16 -07003409 tabla_disable_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE);
Bradley Rubincb1e2732011-06-23 16:49:20 -07003410
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003411 ret = tabla_request_irq(codec->control_data, TABLA_IRQ_SLIMBUS,
3412 tabla_slimbus_irq, "SLIMBUS Slave", tabla);
3413 if (ret) {
3414 pr_err("%s: Failed to request irq %d\n", __func__,
3415 TABLA_IRQ_SLIMBUS);
3416 goto err_slimbus_irq;
3417 }
3418
3419 for (i = 0; i < TABLA_SLIM_NUM_PORT_REG; i++)
3420 tabla_interface_reg_write(codec->control_data,
3421 TABLA_SLIM_PGD_PORT_INT_EN0 + i, 0xFF);
3422
Patrick Lai49efeac2011-11-03 11:01:12 -07003423 ret = tabla_request_irq(codec->control_data,
3424 TABLA_IRQ_HPH_PA_OCPL_FAULT, tabla_hphl_ocp_irq,
3425 "HPH_L OCP detect", tabla);
3426 if (ret) {
3427 pr_err("%s: Failed to request irq %d\n", __func__,
3428 TABLA_IRQ_HPH_PA_OCPL_FAULT);
3429 goto err_hphl_ocp_irq;
3430 }
3431
3432 ret = tabla_request_irq(codec->control_data,
3433 TABLA_IRQ_HPH_PA_OCPR_FAULT, tabla_hphr_ocp_irq,
3434 "HPH_R OCP detect", tabla);
3435 if (ret) {
3436 pr_err("%s: Failed to request irq %d\n", __func__,
3437 TABLA_IRQ_HPH_PA_OCPR_FAULT);
3438 goto err_hphr_ocp_irq;
3439 }
3440
Bradley Rubincb3950a2011-08-18 13:07:26 -07003441#ifdef CONFIG_DEBUG_FS
3442 debug_tabla_priv = tabla;
3443#endif
3444
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003445 return ret;
3446
Patrick Lai49efeac2011-11-03 11:01:12 -07003447err_hphr_ocp_irq:
3448 tabla_free_irq(codec->control_data, TABLA_IRQ_HPH_PA_OCPL_FAULT, tabla);
3449err_hphl_ocp_irq:
3450 tabla_free_irq(codec->control_data, TABLA_IRQ_SLIMBUS, tabla);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003451err_slimbus_irq:
Bradley Rubincb1e2732011-06-23 16:49:20 -07003452 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE, tabla);
3453err_release_irq:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003454 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL, tabla);
3455err_potential_irq:
3456 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL, tabla);
3457err_remove_irq:
3458 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION, tabla);
3459err_insert_irq:
Patrick Lai3043fba2011-08-01 14:15:57 -07003460err_pdata:
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003461 kfree(tabla);
3462 return ret;
3463}
3464static int tabla_codec_remove(struct snd_soc_codec *codec)
3465{
3466 struct tabla_priv *tabla = snd_soc_codec_get_drvdata(codec);
3467 tabla_free_irq(codec->control_data, TABLA_IRQ_SLIMBUS, tabla);
Bradley Rubincb1e2732011-06-23 16:49:20 -07003468 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_RELEASE, tabla);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003469 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_POTENTIAL, tabla);
3470 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_REMOVAL, tabla);
3471 tabla_free_irq(codec->control_data, TABLA_IRQ_MBHC_INSERTION, tabla);
3472 tabla_codec_disable_clock_block(codec);
3473 tabla_codec_enable_bandgap(codec, TABLA_BANDGAP_OFF);
3474 kfree(tabla);
3475 return 0;
3476}
3477static struct snd_soc_codec_driver soc_codec_dev_tabla = {
3478 .probe = tabla_codec_probe,
3479 .remove = tabla_codec_remove,
3480 .read = tabla_read,
3481 .write = tabla_write,
3482
3483 .readable_register = tabla_readable,
3484 .volatile_register = tabla_volatile,
3485
3486 .reg_cache_size = TABLA_CACHE_SIZE,
3487 .reg_cache_default = tabla_reg_defaults,
3488 .reg_word_size = 1,
3489};
Bradley Rubincb3950a2011-08-18 13:07:26 -07003490
3491#ifdef CONFIG_DEBUG_FS
3492static struct dentry *debugfs_poke;
3493
3494static int codec_debug_open(struct inode *inode, struct file *file)
3495{
3496 file->private_data = inode->i_private;
3497 return 0;
3498}
3499
3500static ssize_t codec_debug_write(struct file *filp,
3501 const char __user *ubuf, size_t cnt, loff_t *ppos)
3502{
3503 char lbuf[32];
3504 char *buf;
3505 int rc;
3506
3507 if (cnt > sizeof(lbuf) - 1)
3508 return -EINVAL;
3509
3510 rc = copy_from_user(lbuf, ubuf, cnt);
3511 if (rc)
3512 return -EFAULT;
3513
3514 lbuf[cnt] = '\0';
3515 buf = (char *)lbuf;
3516 debug_tabla_priv->no_mic_headset_override = (*strsep(&buf, " ") == '0')
3517 ? false : true;
3518
3519 return rc;
3520}
3521
3522static const struct file_operations codec_debug_ops = {
3523 .open = codec_debug_open,
3524 .write = codec_debug_write,
3525};
3526#endif
3527
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003528static int __devinit tabla_probe(struct platform_device *pdev)
3529{
Santosh Mardie15e2302011-11-15 10:39:23 +05303530 int ret = 0;
Bradley Rubincb3950a2011-08-18 13:07:26 -07003531#ifdef CONFIG_DEBUG_FS
3532 debugfs_poke = debugfs_create_file("TRRS",
3533 S_IFREG | S_IRUGO, NULL, (void *) "TRRS", &codec_debug_ops);
3534
3535#endif
Santosh Mardie15e2302011-11-15 10:39:23 +05303536 if (tabla_get_intf_type() == TABLA_INTERFACE_TYPE_SLIMBUS)
3537 ret = snd_soc_register_codec(&pdev->dev, &soc_codec_dev_tabla,
3538 tabla_dai, ARRAY_SIZE(tabla_dai));
3539 else if (tabla_get_intf_type() == TABLA_INTERFACE_TYPE_I2C)
3540 ret = snd_soc_register_codec(&pdev->dev, &soc_codec_dev_tabla,
3541 tabla_i2s_dai, ARRAY_SIZE(tabla_i2s_dai));
3542 return ret;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003543}
3544static int __devexit tabla_remove(struct platform_device *pdev)
3545{
3546 snd_soc_unregister_codec(&pdev->dev);
Bradley Rubincb3950a2011-08-18 13:07:26 -07003547
3548#ifdef CONFIG_DEBUG_FS
3549 debugfs_remove(debugfs_poke);
3550#endif
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003551 return 0;
3552}
3553static struct platform_driver tabla_codec_driver = {
3554 .probe = tabla_probe,
3555 .remove = tabla_remove,
3556 .driver = {
3557 .name = "tabla_codec",
3558 .owner = THIS_MODULE,
3559 },
3560};
3561
3562static int __init tabla_codec_init(void)
3563{
3564 return platform_driver_register(&tabla_codec_driver);
3565}
3566
3567static void __exit tabla_codec_exit(void)
3568{
3569 platform_driver_unregister(&tabla_codec_driver);
3570}
3571
3572module_init(tabla_codec_init);
3573module_exit(tabla_codec_exit);
3574
3575MODULE_DESCRIPTION("Tabla codec driver");
3576MODULE_VERSION("1.0");
3577MODULE_LICENSE("GPL v2");