projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: ac97: Add ID for TI TLV320AIC27 codec
[deliverable/linux.git] / sound / pci / hda / patch_conexant.c
CommitLineData
c9b443d4
TD		 1/*
2 * HD audio interface patch for Conexant HDA audio codec
3 *
4 * Copyright (c) 2006 Pototskiy Akex <alex.pototskiy@gmail.com>
5 * Takashi Iwai <tiwai@suse.de>
6 * Tobin Davis <tdavis@dsl-only.net>
7 *
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
c9b443d4
TD		 23#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/slab.h>
26#include <linux/pci.h>
da155d5b 27#include <linux/module.h>
c9b443d4 28#include <sound/core.h>
bc7a166d
UD		 29#include <sound/jack.h>
30
c9b443d4
TD		 31#include "hda_codec.h"
32#include "hda_local.h"
23d30f28 33#include "hda_auto_parser.h"
c0f8faf0 34#include "hda_beep.h"
1835a0f9 35#include "hda_jack.h"
aed523f1 36#include "hda_generic.h"
c9b443d4 37
bf92d1d5 38#define ENABLE_CXT_STATIC_QUIRKS
c9b443d4
TD		 39
40#define CXT_PIN_DIR_IN 0x00
41#define CXT_PIN_DIR_OUT 0x01
42#define CXT_PIN_DIR_INOUT 0x02
43#define CXT_PIN_DIR_IN_NOMICBIAS 0x03
44#define CXT_PIN_DIR_INOUT_NOMICBIAS 0x04
45
46#define CONEXANT_HP_EVENT 0x37
47#define CONEXANT_MIC_EVENT 0x38
03697e2a 48#define CONEXANT_LINE_EVENT 0x39
c9b443d4 49
bc7a166d
UD		 50/* Conexant 5051 specific */
51
ecda0cff 52#define CXT5051_SPDIF_OUT 0x12
bc7a166d
UD		 53#define CXT5051_PORTB_EVENT 0x38
54#define CXT5051_PORTC_EVENT 0x39
c9b443d4 55
faddaa5d
TI		 56#define AUTO_MIC_PORTB (1 << 1)
57#define AUTO_MIC_PORTC (1 << 2)
c9b443d4
TD		 58
59struct conexant_spec {
23d30f28 60 struct hda_gen_spec gen;
c9b443d4 61
bf92d1d5
TI		 62 unsigned int beep_amp;
63
64 /* extra EAPD pins */
65 unsigned int num_eapds;
66 hda_nid_t eapds[4];
ff359b14 67 bool dynamic_eapd;
bf92d1d5 68
e4c3bce2
DH		 69 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
70
bf92d1d5 71#ifdef ENABLE_CXT_STATIC_QUIRKS
34cbe3a6 72 const struct snd_kcontrol_new *mixers[5];
c9b443d4 73 int num_mixers;
dd5746a8 74 hda_nid_t vmaster_nid;
c9b443d4
TD		 75
76 const struct hda_verb *init_verbs[5]; /* initialization verbs
77 * don't forget NULL
78 * termination!
79 */
80 unsigned int num_init_verbs;
81
82 /* playback */
83 struct hda_multi_out multiout; /* playback set-up
84 * max_channels, dacs must be set
85 * dig_out_nid and hp_nid are optional
86 */
87 unsigned int cur_eapd;
82f30040 88 unsigned int hp_present;
03697e2a 89 unsigned int line_present;
faddaa5d 90 unsigned int auto_mic;
c9b443d4
TD		 91
92 /* capture */
93 unsigned int num_adc_nids;
34cbe3a6 94 const hda_nid_t *adc_nids;
c9b443d4
TD		 95 hda_nid_t dig_in_nid; /* digital-in NID; optional */
96
461e2c78
TI		 97 unsigned int cur_adc_idx;
98 hda_nid_t cur_adc;
99 unsigned int cur_adc_stream_tag;
100 unsigned int cur_adc_format;
101
6764bcef
TI		 102 const struct hda_pcm_stream *capture_stream;
103
c9b443d4
TD		 104 /* capture source */
105 const struct hda_input_mux *input_mux;
34cbe3a6 106 const hda_nid_t *capsrc_nids;
c9b443d4
TD		 107 unsigned int cur_mux[3];
108
109 /* channel model */
110 const struct hda_channel_mode *channel_mode;
111 int num_channel_mode;
112
113 /* PCM information */
114 struct hda_pcm pcm_rec[2]; /* used in build_pcms() */
115
c9b443d4
TD		 116 unsigned int spdif_route;
117
0fb67e98 118 unsigned int port_d_mode;
f2e5731d 119 unsigned int dell_automute:1;
cfd3d8dc
GA		 120 unsigned int dell_vostro:1;
121 unsigned int ideapad:1;
7b2bfdbc 122 unsigned int thinkpad:1;
048e78a5 123 unsigned int hp_laptop:1;
a1d6906e 124 unsigned int asus:1;
6764bcef 125
75f8991d
DD		 126 unsigned int ext_mic_present;
127 unsigned int recording;
128 void (*capture_prepare)(struct hda_codec *codec);
129 void (*capture_cleanup)(struct hda_codec *codec);
c4cfe66c
DD		 130
131 /* OLPC XO-1.5 supports DC input mode (e.g. for use with analog sensors)
132 * through the microphone jack.
133 * When the user enables this through a mixer switch, both internal and
134 * external microphones are disabled. Gain is fixed at 0dB. In this mode,
135 * we also allow the bias to be configured through a separate mixer
136 * control. */
137 unsigned int dc_enable;
138 unsigned int dc_input_bias; /* offset into cxt5066_olpc_dc_bias */
139 unsigned int mic_boost; /* offset into cxt5066_analog_mic_boost */
bf92d1d5
TI		 140#endif /* ENABLE_CXT_STATIC_QUIRKS */
141};
3507e2a8 142
19110595 143
bf92d1d5 144#ifdef CONFIG_SND_HDA_INPUT_BEEP
7504b6cd
TI		 145static inline void set_beep_amp(struct conexant_spec *spec, hda_nid_t nid,
146 int idx, int dir)
147{
148 spec->gen.beep_nid = nid;
149 spec->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir);
150}
bf92d1d5
TI		 151/* additional beep mixers; the actual parameters are overwritten at build */
152static const struct snd_kcontrol_new cxt_beep_mixer[] = {
153 HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0, 1, 0, HDA_OUTPUT),
154 HDA_CODEC_MUTE_BEEP_MONO("Beep Playback Switch", 0, 1, 0, HDA_OUTPUT),
155 { } /* end */
c9b443d4
TD		 156};
157
bf92d1d5
TI		 158/* create beep controls if needed */
159static int add_beep_ctls(struct hda_codec *codec)
160{
161 struct conexant_spec *spec = codec->spec;
162 int err;
163
164 if (spec->beep_amp) {
165 const struct snd_kcontrol_new *knew;
166 for (knew = cxt_beep_mixer; knew->name; knew++) {
167 struct snd_kcontrol *kctl;
168 kctl = snd_ctl_new1(knew, codec);
169 if (!kctl)
170 return -ENOMEM;
171 kctl->private_value = spec->beep_amp;
172 err = snd_hda_ctl_add(codec, 0, kctl);
173 if (err < 0)
174 return err;
175 }
176 }
177 return 0;
178}
179#else
180#define set_beep_amp(spec, nid, idx, dir) /* NOP */
181#define add_beep_ctls(codec) 0
182#endif
183
184
185#ifdef ENABLE_CXT_STATIC_QUIRKS
c9b443d4
TD		 186static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
187 struct hda_codec *codec,
188 struct snd_pcm_substream *substream)
189{
190 struct conexant_spec *spec = codec->spec;
9a08160b
TI		 191 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
192 hinfo);
c9b443d4
TD		 193}
194
195static int conexant_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
196 struct hda_codec *codec,
197 unsigned int stream_tag,
198 unsigned int format,
199 struct snd_pcm_substream *substream)
200{
201 struct conexant_spec *spec = codec->spec;
202 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
203 stream_tag,
204 format, substream);
205}
206
207static int conexant_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
208 struct hda_codec *codec,
209 struct snd_pcm_substream *substream)
210{
211 struct conexant_spec *spec = codec->spec;
212 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
213}
214
215/*
216 * Digital out
217 */
218static int conexant_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
219 struct hda_codec *codec,
220 struct snd_pcm_substream *substream)
221{
222 struct conexant_spec *spec = codec->spec;
223 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
224}
225
226static int conexant_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
227 struct hda_codec *codec,
228 struct snd_pcm_substream *substream)
229{
230 struct conexant_spec *spec = codec->spec;
231 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
232}
233
6b97eb45
TI		 234static int conexant_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
235 struct hda_codec *codec,
236 unsigned int stream_tag,
237 unsigned int format,
238 struct snd_pcm_substream *substream)
239{
240 struct conexant_spec *spec = codec->spec;
241 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
242 stream_tag,
243 format, substream);
244}
245
c9b443d4
TD		 246/*
247 * Analog capture
248 */
249static int conexant_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
250 struct hda_codec *codec,
251 unsigned int stream_tag,
252 unsigned int format,
253 struct snd_pcm_substream *substream)
254{
255 struct conexant_spec *spec = codec->spec;
75f8991d
DD		 256 if (spec->capture_prepare)
257 spec->capture_prepare(codec);
c9b443d4
TD		 258 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
259 stream_tag, 0, format);
260 return 0;
261}
262
263static int conexant_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
264 struct hda_codec *codec,
265 struct snd_pcm_substream *substream)
266{
267 struct conexant_spec *spec = codec->spec;
888afa15 268 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
75f8991d
DD		 269 if (spec->capture_cleanup)
270 spec->capture_cleanup(codec);
c9b443d4
TD		 271 return 0;
272}
273
274
275
34cbe3a6 276static const struct hda_pcm_stream conexant_pcm_analog_playback = {
c9b443d4
TD		 277 .substreams = 1,
278 .channels_min = 2,
279 .channels_max = 2,
280 .nid = 0, /* fill later */
281 .ops = {
282 .open = conexant_playback_pcm_open,
283 .prepare = conexant_playback_pcm_prepare,
284 .cleanup = conexant_playback_pcm_cleanup
285 },
286};
287
34cbe3a6 288static const struct hda_pcm_stream conexant_pcm_analog_capture = {
c9b443d4
TD		 289 .substreams = 1,
290 .channels_min = 2,
291 .channels_max = 2,
292 .nid = 0, /* fill later */
293 .ops = {
294 .prepare = conexant_capture_pcm_prepare,
295 .cleanup = conexant_capture_pcm_cleanup
296 },
297};
298
299
34cbe3a6 300static const struct hda_pcm_stream conexant_pcm_digital_playback = {
c9b443d4
TD		 301 .substreams = 1,
302 .channels_min = 2,
303 .channels_max = 2,
304 .nid = 0, /* fill later */
305 .ops = {
306 .open = conexant_dig_playback_pcm_open,
6b97eb45
TI		 307 .close = conexant_dig_playback_pcm_close,
308 .prepare = conexant_dig_playback_pcm_prepare
c9b443d4
TD		 309 },
310};
311
34cbe3a6 312static const struct hda_pcm_stream conexant_pcm_digital_capture = {
c9b443d4
TD		 313 .substreams = 1,
314 .channels_min = 2,
315 .channels_max = 2,
316 /* NID is set in alc_build_pcms */
317};
318
461e2c78
TI		 319static int cx5051_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
320 struct hda_codec *codec,
321 unsigned int stream_tag,
322 unsigned int format,
323 struct snd_pcm_substream *substream)
324{
325 struct conexant_spec *spec = codec->spec;
326 spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
327 spec->cur_adc_stream_tag = stream_tag;
328 spec->cur_adc_format = format;
329 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
330 return 0;
331}
332
333static int cx5051_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
334 struct hda_codec *codec,
335 struct snd_pcm_substream *substream)
336{
337 struct conexant_spec *spec = codec->spec;
888afa15 338 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
461e2c78
TI		 339 spec->cur_adc = 0;
340 return 0;
341}
342
34cbe3a6 343static const struct hda_pcm_stream cx5051_pcm_analog_capture = {
461e2c78
TI		 344 .substreams = 1,
345 .channels_min = 2,
346 .channels_max = 2,
347 .nid = 0, /* fill later */
348 .ops = {
349 .prepare = cx5051_capture_pcm_prepare,
350 .cleanup = cx5051_capture_pcm_cleanup
351 },
352};
353
c9b443d4
TD		 354static int conexant_build_pcms(struct hda_codec *codec)
355{
356 struct conexant_spec *spec = codec->spec;
357 struct hda_pcm *info = spec->pcm_rec;
358
359 codec->num_pcms = 1;
360 codec->pcm_info = info;
361
362 info->name = "CONEXANT Analog";
363 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = conexant_pcm_analog_playback;
364 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
365 spec->multiout.max_channels;
366 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
367 spec->multiout.dac_nids[0];
6764bcef
TI		 368 if (spec->capture_stream)
369 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *spec->capture_stream;
370 else {
371 if (codec->vendor_id == 0x14f15051)
372 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
373 cx5051_pcm_analog_capture;
374 else {
375 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
376 conexant_pcm_analog_capture;
377 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
378 spec->num_adc_nids;
379 }
380 }
c9b443d4
TD		 381 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
382
383 if (spec->multiout.dig_out_nid) {
384 info++;
385 codec->num_pcms++;
386 info->name = "Conexant Digital";
7ba72ba1 387 info->pcm_type = HDA_PCM_TYPE_SPDIF;
c9b443d4
TD		 388 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
389 conexant_pcm_digital_playback;
390 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
391 spec->multiout.dig_out_nid;
392 if (spec->dig_in_nid) {
393 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
394 conexant_pcm_digital_capture;
395 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
396 spec->dig_in_nid;
397 }
398 }
399
400 return 0;
401}
402
403static int conexant_mux_enum_info(struct snd_kcontrol *kcontrol,
404 struct snd_ctl_elem_info *uinfo)
405{
406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
407 struct conexant_spec *spec = codec->spec;
408
409 return snd_hda_input_mux_info(spec->input_mux, uinfo);
410}
411
412static int conexant_mux_enum_get(struct snd_kcontrol *kcontrol,
413 struct snd_ctl_elem_value *ucontrol)
414{
415 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
416 struct conexant_spec *spec = codec->spec;
417 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
418
419 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
420 return 0;
421}
422
423static int conexant_mux_enum_put(struct snd_kcontrol *kcontrol,
424 struct snd_ctl_elem_value *ucontrol)
425{
426 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
427 struct conexant_spec *spec = codec->spec;
428 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
429
430 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
431 spec->capsrc_nids[adc_idx],
432 &spec->cur_mux[adc_idx]);
433}
434
4d7fbdbc
TI		 435static void conexant_set_power(struct hda_codec *codec, hda_nid_t fg,
436 unsigned int power_state)
437{
438 if (power_state == AC_PWRST_D3)
439 msleep(100);
440 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
441 power_state);
442 /* partial workaround for "azx_get_response timeout" */
443 if (power_state == AC_PWRST_D0)
444 msleep(10);
9419ab6b 445 snd_hda_codec_set_power_to_all(codec, fg, power_state);
4d7fbdbc
TI		 446}
447
c9b443d4
TD		 448static int conexant_init(struct hda_codec *codec)
449{
450 struct conexant_spec *spec = codec->spec;
451 int i;
452
453 for (i = 0; i < spec->num_init_verbs; i++)
454 snd_hda_sequence_write(codec, spec->init_verbs[i]);
455 return 0;
456}
457
458static void conexant_free(struct hda_codec *codec)
459{
ee48df57 460 struct conexant_spec *spec = codec->spec;
c0f8faf0 461 snd_hda_detach_beep_device(codec);
ee48df57 462 kfree(spec);
c9b443d4
TD		 463}
464
34cbe3a6 465static const struct snd_kcontrol_new cxt_capture_mixers[] = {
b880c74a
TI		 466 {
467 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
468 .name = "Capture Source",
469 .info = conexant_mux_enum_info,
470 .get = conexant_mux_enum_get,
471 .put = conexant_mux_enum_put
472 },
473 {}
474};
475
9322ca54 476static const char * const slave_pfxs[] = {
f37bc7a8 477 "Headphone", "Speaker", "Bass Speaker", "Front", "Surround", "CLFE",
dd5746a8
TI		 478 NULL
479};
480
c9b443d4
TD		 481static int conexant_build_controls(struct hda_codec *codec)
482{
483 struct conexant_spec *spec = codec->spec;
484 unsigned int i;
485 int err;
486
487 for (i = 0; i < spec->num_mixers; i++) {
488 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
489 if (err < 0)
490 return err;
491 }
492 if (spec->multiout.dig_out_nid) {
493 err = snd_hda_create_spdif_out_ctls(codec,
74b654c9 494 spec->multiout.dig_out_nid,
c9b443d4
TD		 495 spec->multiout.dig_out_nid);
496 if (err < 0)
497 return err;
9a08160b
TI		 498 err = snd_hda_create_spdif_share_sw(codec,
499 &spec->multiout);
500 if (err < 0)
501 return err;
502 spec->multiout.share_spdif = 1;
c9b443d4
TD		 503 }
504 if (spec->dig_in_nid) {
505 err = snd_hda_create_spdif_in_ctls(codec,spec->dig_in_nid);
506 if (err < 0)
507 return err;
508 }
dd5746a8
TI		 509
510 /* if we have no master control, let's create it */
511 if (spec->vmaster_nid &&
512 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
513 unsigned int vmaster_tlv[4];
514 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
515 HDA_OUTPUT, vmaster_tlv);
516 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
9322ca54
TI		 517 vmaster_tlv, slave_pfxs,
518 "Playback Volume");
dd5746a8
TI		 519 if (err < 0)
520 return err;
521 }
522 if (spec->vmaster_nid &&
523 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
aed523f1
TI		 524 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
525 NULL, slave_pfxs,
526 "Playback Switch");
dd5746a8
TI		 527 if (err < 0)
528 return err;
529 }
530
b880c74a
TI		 531 if (spec->input_mux) {
532 err = snd_hda_add_new_ctls(codec, cxt_capture_mixers);
533 if (err < 0)
534 return err;
535 }
536
aed523f1
TI		 537 err = add_beep_ctls(codec);
538 if (err < 0)
539 return err;
3507e2a8 540
c9b443d4
TD		 541 return 0;
542}
543
34cbe3a6 544static const struct hda_codec_ops conexant_patch_ops = {
c9b443d4
TD		 545 .build_controls = conexant_build_controls,
546 .build_pcms = conexant_build_pcms,
547 .init = conexant_init,
548 .free = conexant_free,
4d7fbdbc 549 .set_power_state = conexant_set_power,
c9b443d4
TD		 550};
551
6764bcef 552static int patch_conexant_auto(struct hda_codec *codec);
c9b443d4
TD		 553/*
554 * EAPD control
555 * the private value = nid | (invert << 8)
556 */
557
a5ce8890 558#define cxt_eapd_info snd_ctl_boolean_mono_info
c9b443d4 559
82f30040 560static int cxt_eapd_get(struct snd_kcontrol *kcontrol,
c9b443d4
TD		 561 struct snd_ctl_elem_value *ucontrol)
562{
563 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
564 struct conexant_spec *spec = codec->spec;
565 int invert = (kcontrol->private_value >> 8) & 1;
566 if (invert)
567 ucontrol->value.integer.value[0] = !spec->cur_eapd;
568 else
569 ucontrol->value.integer.value[0] = spec->cur_eapd;
570 return 0;
82f30040 571
c9b443d4
TD		 572}
573
82f30040 574static int cxt_eapd_put(struct snd_kcontrol *kcontrol,
c9b443d4
TD		 575 struct snd_ctl_elem_value *ucontrol)
576{
577 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
578 struct conexant_spec *spec = codec->spec;
579 int invert = (kcontrol->private_value >> 8) & 1;
580 hda_nid_t nid = kcontrol->private_value & 0xff;
581 unsigned int eapd;
82f30040 582
68ea7b2f 583 eapd = !!ucontrol->value.integer.value[0];
c9b443d4
TD		 584 if (invert)
585 eapd = !eapd;
82beb8fd 586 if (eapd == spec->cur_eapd)
c9b443d4 587 return 0;
82f30040 588
c9b443d4 589 spec->cur_eapd = eapd;
82beb8fd
TI		 590 snd_hda_codec_write_cache(codec, nid,
591 0, AC_VERB_SET_EAPD_BTLENABLE,
592 eapd ? 0x02 : 0x00);
c9b443d4
TD		 593 return 1;
594}
595
86d72bdf
TI		 596/* controls for test mode */
597#ifdef CONFIG_SND_DEBUG
598
82f30040
TD		 599#define CXT_EAPD_SWITCH(xname, nid, mask) \
600 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
601 .info = cxt_eapd_info, \
602 .get = cxt_eapd_get, \
603 .put = cxt_eapd_put, \
604 .private_value = nid | (mask<<16) }
605
606
607
c9b443d4
TD		 608static int conexant_ch_mode_info(struct snd_kcontrol *kcontrol,
609 struct snd_ctl_elem_info *uinfo)
610{
611 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
612 struct conexant_spec *spec = codec->spec;
613 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
614 spec->num_channel_mode);
615}
616
617static int conexant_ch_mode_get(struct snd_kcontrol *kcontrol,
618 struct snd_ctl_elem_value *ucontrol)
619{
620 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
621 struct conexant_spec *spec = codec->spec;
622 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
623 spec->num_channel_mode,
624 spec->multiout.max_channels);
625}
626
627static int conexant_ch_mode_put(struct snd_kcontrol *kcontrol,
628 struct snd_ctl_elem_value *ucontrol)
629{
630 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
631 struct conexant_spec *spec = codec->spec;
632 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
633 spec->num_channel_mode,
634 &spec->multiout.max_channels);
c9b443d4
TD		 635 return err;
636}
637
638#define CXT_PIN_MODE(xname, nid, dir) \
639 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
640 .info = conexant_ch_mode_info, \
641 .get = conexant_ch_mode_get, \
642 .put = conexant_ch_mode_put, \
643 .private_value = nid | (dir<<16) }
644
86d72bdf
TI		 645#endif /* CONFIG_SND_DEBUG */
646
c9b443d4
TD		 647/* Conexant 5045 specific */
648
34cbe3a6
TI		 649static const hda_nid_t cxt5045_dac_nids[1] = { 0x19 };
650static const hda_nid_t cxt5045_adc_nids[1] = { 0x1a };
651static const hda_nid_t cxt5045_capsrc_nids[1] = { 0x1a };
cbef9789 652#define CXT5045_SPDIF_OUT 0x18
c9b443d4 653
34cbe3a6 654static const struct hda_channel_mode cxt5045_modes[1] = {
5cd57529
TD		 655 { 2, NULL },
656};
c9b443d4 657
34cbe3a6 658static const struct hda_input_mux cxt5045_capture_source = {
c9b443d4
TD		 659 .num_items = 2,
660 .items = {
3edbbb9e
MK		 661 { "Internal Mic", 0x1 },
662 { "Mic", 0x2 },
c9b443d4
TD		 663 }
664};
665
34cbe3a6 666static const struct hda_input_mux cxt5045_capture_source_benq = {
e6e03dae 667 .num_items = 4,
5218c892 668 .items = {
3edbbb9e
MK		 669 { "Internal Mic", 0x1 },
670 { "Mic", 0x2 },
671 { "Line", 0x3 },
672 { "Mixer", 0x0 },
5218c892
JZ		 673 }
674};
675
34cbe3a6 676static const struct hda_input_mux cxt5045_capture_source_hp530 = {
2de3c232
J		 677 .num_items = 2,
678 .items = {
3edbbb9e
MK		 679 { "Mic", 0x1 },
680 { "Internal Mic", 0x2 },
2de3c232
J		 681 }
682};
683
c9b443d4
TD		 684/* turn on/off EAPD (+ mute HP) as a master switch */
685static int cxt5045_hp_master_sw_put(struct snd_kcontrol *kcontrol,
686 struct snd_ctl_elem_value *ucontrol)
687{
688 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
689 struct conexant_spec *spec = codec->spec;
82f30040 690 unsigned int bits;
c9b443d4 691
82f30040 692 if (!cxt_eapd_put(kcontrol, ucontrol))
c9b443d4
TD		 693 return 0;
694
82f30040
TD		 695 /* toggle internal speakers mute depending of presence of
696 * the headphone jack
697 */
47fd830a
TI		 698 bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE;
699 snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0,
700 HDA_AMP_MUTE, bits);
7f29673b 701
47fd830a
TI		 702 bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE;
703 snd_hda_codec_amp_stereo(codec, 0x11, HDA_OUTPUT, 0,
704 HDA_AMP_MUTE, bits);
c9b443d4
TD		 705 return 1;
706}
707
708/* bind volumes of both NID 0x10 and 0x11 */
34cbe3a6 709static const struct hda_bind_ctls cxt5045_hp_bind_master_vol = {
cca3b371
TI		 710 .ops = &snd_hda_bind_vol,
711 .values = {
712 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT),
713 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
714 0
715 },
716};
c9b443d4 717
7f29673b
TD		 718/* toggle input of built-in and mic jack appropriately */
719static void cxt5045_hp_automic(struct hda_codec *codec)
720{
34cbe3a6 721 static const struct hda_verb mic_jack_on[] = {
7f29673b
TD		 722 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
723 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
724 {}
725 };
34cbe3a6 726 static const struct hda_verb mic_jack_off[] = {
7f29673b
TD		 727 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
728 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
729 {}
730 };
731 unsigned int present;
732
d56757ab 733 present = snd_hda_jack_detect(codec, 0x12);
7f29673b
TD		 734 if (present)
735 snd_hda_sequence_write(codec, mic_jack_on);
736 else
737 snd_hda_sequence_write(codec, mic_jack_off);
738}
739
c9b443d4
TD		 740
741/* mute internal speaker if HP is plugged */
742static void cxt5045_hp_automute(struct hda_codec *codec)
743{
82f30040 744 struct conexant_spec *spec = codec->spec;
dd87da1c 745 unsigned int bits;
c9b443d4 746
d56757ab 747 spec->hp_present = snd_hda_jack_detect(codec, 0x11);
dd87da1c 748
47fd830a
TI		 749 bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
750 snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0,
751 HDA_AMP_MUTE, bits);
c9b443d4
TD		 752}
753
754/* unsolicited event for HP jack sensing */
755static void cxt5045_hp_unsol_event(struct hda_codec *codec,
756 unsigned int res)
757{
758 res >>= 26;
759 switch (res) {
760 case CONEXANT_HP_EVENT:
761 cxt5045_hp_automute(codec);
762 break;
7f29673b
TD		 763 case CONEXANT_MIC_EVENT:
764 cxt5045_hp_automic(codec);
765 break;
766
c9b443d4
TD		 767 }
768}
769
34cbe3a6 770static const struct snd_kcontrol_new cxt5045_mixers[] = {
cbf2d28e
MK		 771 HDA_CODEC_VOLUME("Capture Volume", 0x1a, 0x00, HDA_INPUT),
772 HDA_CODEC_MUTE("Capture Switch", 0x1a, 0x0, HDA_INPUT),
c8229c38
TI		 773 HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT),
774 HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT),
28c4edb7
DH		 775 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x1, HDA_INPUT),
776 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x1, HDA_INPUT),
8607f7c4
DH		 777 HDA_CODEC_VOLUME("Mic Playback Volume", 0x17, 0x2, HDA_INPUT),
778 HDA_CODEC_MUTE("Mic Playback Switch", 0x17, 0x2, HDA_INPUT),
cca3b371 779 HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol),
c9b443d4
TD		 780 {
781 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
782 .name = "Master Playback Switch",
82f30040
TD		 783 .info = cxt_eapd_info,
784 .get = cxt_eapd_get,
c9b443d4 785 .put = cxt5045_hp_master_sw_put,
82f30040 786 .private_value = 0x10,
c9b443d4
TD		 787 },
788
789 {}
790};
791
34cbe3a6 792static const struct snd_kcontrol_new cxt5045_benq_mixers[] = {
3edbbb9e
MK		 793 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x3, HDA_INPUT),
794 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x3, HDA_INPUT),
22e14130 795
5218c892
JZ		 796 {}
797};
798
34cbe3a6 799static const struct snd_kcontrol_new cxt5045_mixers_hp530[] = {
cbf2d28e
MK		 800 HDA_CODEC_VOLUME("Capture Volume", 0x1a, 0x00, HDA_INPUT),
801 HDA_CODEC_MUTE("Capture Switch", 0x1a, 0x0, HDA_INPUT),
2de3c232
J		 802 HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT),
803 HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT),
28c4edb7
DH		 804 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x2, HDA_INPUT),
805 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x2, HDA_INPUT),
8607f7c4
DH		 806 HDA_CODEC_VOLUME("Mic Playback Volume", 0x17, 0x1, HDA_INPUT),
807 HDA_CODEC_MUTE("Mic Playback Switch", 0x17, 0x1, HDA_INPUT),
2de3c232
J		 808 HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol),
809 {
810 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
811 .name = "Master Playback Switch",
812 .info = cxt_eapd_info,
813 .get = cxt_eapd_get,
814 .put = cxt5045_hp_master_sw_put,
815 .private_value = 0x10,
816 },
817
818 {}
819};
820
34cbe3a6 821static const struct hda_verb cxt5045_init_verbs[] = {
c9b443d4 822 /* Line in, Mic */
4090dffb 823 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
7f29673b 824 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
c9b443d4 825 /* HP, Amp */
c8229c38
TI		 826 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
827 {0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
828 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
829 {0x11, AC_VERB_SET_CONNECT_SEL, 0x1},
830 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
831 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
832 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
833 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
834 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
28c4edb7 835 /* Record selector: Internal mic */
7f29673b 836 {0x1a, AC_VERB_SET_CONNECT_SEL,0x1},
82f30040 837 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE,
c9b443d4
TD		 838 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
839 /* SPDIF route: PCM */
cbef9789 840 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
c9b443d4 841 { 0x13, AC_VERB_SET_CONNECT_SEL, 0x0 },
c9b443d4 842 /* EAPD */
82f30040 843 {0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2 }, /* default on */
c9b443d4
TD		 844 { } /* end */
845};
846
34cbe3a6 847static const struct hda_verb cxt5045_benq_init_verbs[] = {
28c4edb7 848 /* Internal Mic, Mic */
5218c892
JZ		 849 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
850 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
851 /* Line In,HP, Amp */
852 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
853 {0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
854 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
855 {0x11, AC_VERB_SET_CONNECT_SEL, 0x1},
856 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
857 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
858 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
859 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
860 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
28c4edb7 861 /* Record selector: Internal mic */
5218c892
JZ		 862 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x1},
863 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE,
864 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
865 /* SPDIF route: PCM */
cbef9789 866 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5218c892
JZ		 867 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
868 /* EAPD */
869 {0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
870 { } /* end */
871};
7f29673b 872
34cbe3a6 873static const struct hda_verb cxt5045_hp_sense_init_verbs[] = {
7f29673b
TD		 874 /* pin sensing on HP jack */
875 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
d3091fad 876 { } /* end */
7f29673b
TD		 877};
878
34cbe3a6 879static const struct hda_verb cxt5045_mic_sense_init_verbs[] = {
7f29673b
TD		 880 /* pin sensing on HP jack */
881 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
d3091fad 882 { } /* end */
7f29673b
TD		 883};
884
c9b443d4
TD		 885#ifdef CONFIG_SND_DEBUG
886/* Test configuration for debugging, modelled after the ALC260 test
887 * configuration.
888 */
34cbe3a6 889static const struct hda_input_mux cxt5045_test_capture_source = {
c9b443d4
TD		 890 .num_items = 5,
891 .items = {
892 { "MIXER", 0x0 },
893 { "MIC1 pin", 0x1 },
894 { "LINE1 pin", 0x2 },
895 { "HP-OUT pin", 0x3 },
896 { "CD pin", 0x4 },
897 },
898};
899
34cbe3a6 900static const struct snd_kcontrol_new cxt5045_test_mixer[] = {
c9b443d4
TD		 901
902 /* Output controls */
c9b443d4
TD		 903 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x10, 0x0, HDA_OUTPUT),
904 HDA_CODEC_MUTE("Speaker Playback Switch", 0x10, 0x0, HDA_OUTPUT),
250f3274
MK		 905 HDA_CODEC_VOLUME("HP-OUT Playback Volume", 0x11, 0x0, HDA_OUTPUT),
906 HDA_CODEC_MUTE("HP-OUT Playback Switch", 0x11, 0x0, HDA_OUTPUT),
907 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x12, 0x0, HDA_OUTPUT),
908 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x12, 0x0, HDA_OUTPUT),
c9b443d4
TD		 909
910 /* Modes for retasking pin widgets */
911 CXT_PIN_MODE("HP-OUT pin mode", 0x11, CXT_PIN_DIR_INOUT),
912 CXT_PIN_MODE("LINE1 pin mode", 0x12, CXT_PIN_DIR_INOUT),
913
82f30040
TD		 914 /* EAPD Switch Control */
915 CXT_EAPD_SWITCH("External Amplifier", 0x10, 0x0),
916
c9b443d4 917 /* Loopback mixer controls */
7f29673b 918
250f3274
MK		 919 HDA_CODEC_VOLUME("PCM Volume", 0x17, 0x0, HDA_INPUT),
920 HDA_CODEC_MUTE("PCM Switch", 0x17, 0x0, HDA_INPUT),
921 HDA_CODEC_VOLUME("MIC1 pin Volume", 0x17, 0x1, HDA_INPUT),
922 HDA_CODEC_MUTE("MIC1 pin Switch", 0x17, 0x1, HDA_INPUT),
923 HDA_CODEC_VOLUME("LINE1 pin Volume", 0x17, 0x2, HDA_INPUT),
924 HDA_CODEC_MUTE("LINE1 pin Switch", 0x17, 0x2, HDA_INPUT),
925 HDA_CODEC_VOLUME("HP-OUT pin Volume", 0x17, 0x3, HDA_INPUT),
926 HDA_CODEC_MUTE("HP-OUT pin Switch", 0x17, 0x3, HDA_INPUT),
927 HDA_CODEC_VOLUME("CD pin Volume", 0x17, 0x4, HDA_INPUT),
928 HDA_CODEC_MUTE("CD pin Switch", 0x17, 0x4, HDA_INPUT),
c9b443d4
TD		 929 {
930 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
931 .name = "Input Source",
932 .info = conexant_mux_enum_info,
933 .get = conexant_mux_enum_get,
934 .put = conexant_mux_enum_put,
935 },
fb3409e7 936 /* Audio input controls */
cbf2d28e
MK		 937 HDA_CODEC_VOLUME("Capture Volume", 0x1a, 0x0, HDA_INPUT),
938 HDA_CODEC_MUTE("Capture Switch", 0x1a, 0x0, HDA_INPUT),
c9b443d4
TD		 939 { } /* end */
940};
941
34cbe3a6 942static const struct hda_verb cxt5045_test_init_verbs[] = {
7f29673b
TD		 943 /* Set connections */
944 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
945 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x0 },
946 { 0x12, AC_VERB_SET_CONNECT_SEL, 0x0 },
c9b443d4
TD		 947 /* Enable retasking pins as output, initially without power amp */
948 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7f29673b 949 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
c9b443d4
TD		 950
951 /* Disable digital (SPDIF) pins initially, but users can enable
952 * them via a mixer switch. In the case of SPDIF-out, this initverb
953 * payload also sets the generation to 0, output to be in "consumer"
954 * PCM format, copyright asserted, no pre-emphasis and no validity
955 * control.
956 */
cbef9789
TI		 957 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
958 {0x18, AC_VERB_SET_DIGI_CONVERT_1, 0},
c9b443d4 959
c9b443d4
TD		 960 /* Unmute retasking pin widget output buffers since the default
961 * state appears to be output. As the pin mode is changed by the
962 * user the pin mode control will take care of enabling the pin's
963 * input/output buffers as needed.
964 */
965 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
966 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
967
968 /* Mute capture amp left and right */
969 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
970
971 /* Set ADC connection select to match default mixer setting (mic1
972 * pin)
973 */
250f3274
MK		 974 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
975 {0x17, AC_VERB_SET_CONNECT_SEL, 0x01},
c9b443d4
TD		 976
977 /* Mute all inputs to mixer widget (even unconnected ones) */
250f3274 978 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* Mixer */
c9b443d4
TD		 979 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* Mic1 pin */
980 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* Line pin */
981 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* HP pin */
982 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
983
984 { }
985};
986#endif
987
988
989/* initialize jack-sensing, too */
990static int cxt5045_init(struct hda_codec *codec)
991{
992 conexant_init(codec);
993 cxt5045_hp_automute(codec);
994 return 0;
995}
996
997
998enum {
15908c36
MB		 999 CXT5045_LAPTOP_HPSENSE,
1000 CXT5045_LAPTOP_MICSENSE,
1001 CXT5045_LAPTOP_HPMICSENSE,
5218c892 1002 CXT5045_BENQ,
2de3c232 1003 CXT5045_LAPTOP_HP530,
c9b443d4
TD		 1004#ifdef CONFIG_SND_DEBUG
1005 CXT5045_TEST,
1006#endif
1f8458a2 1007 CXT5045_AUTO,
f5fcc13c 1008 CXT5045_MODELS
c9b443d4
TD		 1009};
1010
ea734963 1011static const char * const cxt5045_models[CXT5045_MODELS] = {
15908c36
MB		 1012 [CXT5045_LAPTOP_HPSENSE] = "laptop-hpsense",
1013 [CXT5045_LAPTOP_MICSENSE] = "laptop-micsense",
1014 [CXT5045_LAPTOP_HPMICSENSE] = "laptop-hpmicsense",
1015 [CXT5045_BENQ] = "benq",
2de3c232 1016 [CXT5045_LAPTOP_HP530] = "laptop-hp530",
c9b443d4 1017#ifdef CONFIG_SND_DEBUG
f5fcc13c 1018 [CXT5045_TEST] = "test",
c9b443d4 1019#endif
1f8458a2 1020 [CXT5045_AUTO] = "auto",
f5fcc13c
TI		 1021};
1022
34cbe3a6 1023static const struct snd_pci_quirk cxt5045_cfg_tbl[] = {
2de3c232 1024 SND_PCI_QUIRK(0x103c, 0x30d5, "HP 530", CXT5045_LAPTOP_HP530),
6a9dccd6 1025 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P105", CXT5045_LAPTOP_MICSENSE),
5218c892 1026 SND_PCI_QUIRK(0x152d, 0x0753, "Benq R55E", CXT5045_BENQ),
15908c36
MB		 1027 SND_PCI_QUIRK(0x1734, 0x10ad, "Fujitsu Si1520", CXT5045_LAPTOP_MICSENSE),
1028 SND_PCI_QUIRK(0x1734, 0x10cb, "Fujitsu Si3515", CXT5045_LAPTOP_HPMICSENSE),
9e464154
TI		 1029 SND_PCI_QUIRK(0x1734, 0x110e, "Fujitsu V5505",
1030 CXT5045_LAPTOP_HPMICSENSE),
15908c36
MB		 1031 SND_PCI_QUIRK(0x1509, 0x1e40, "FIC", CXT5045_LAPTOP_HPMICSENSE),
1032 SND_PCI_QUIRK(0x1509, 0x2f05, "FIC", CXT5045_LAPTOP_HPMICSENSE),
1033 SND_PCI_QUIRK(0x1509, 0x2f06, "FIC", CXT5045_LAPTOP_HPMICSENSE),
dea0a509
TI		 1034 SND_PCI_QUIRK_MASK(0x1631, 0xff00, 0xc100, "Packard Bell",
1035 CXT5045_LAPTOP_HPMICSENSE),
15908c36 1036 SND_PCI_QUIRK(0x8086, 0x2111, "Conexant Reference board", CXT5045_LAPTOP_HPSENSE),
c9b443d4
TD		 1037 {}
1038};
1039
1040static int patch_cxt5045(struct hda_codec *codec)
1041{
1042 struct conexant_spec *spec;
1043 int board_config;
1044
1f8458a2
TI		 1045 board_config = snd_hda_check_board_config(codec, CXT5045_MODELS,
1046 cxt5045_models,
1047 cxt5045_cfg_tbl);
1048 if (board_config < 0)
c82693db 1049 board_config = CXT5045_AUTO; /* model=auto as default */
1f8458a2
TI		 1050 if (board_config == CXT5045_AUTO)
1051 return patch_conexant_auto(codec);
1052
c9b443d4
TD		 1053 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1054 if (!spec)
1055 return -ENOMEM;
c9b443d4 1056 codec->spec = spec;
4f32456e 1057 codec->single_adc_amp = 1;
c9b443d4
TD		 1058
1059 spec->multiout.max_channels = 2;
1060 spec->multiout.num_dacs = ARRAY_SIZE(cxt5045_dac_nids);
1061 spec->multiout.dac_nids = cxt5045_dac_nids;
1062 spec->multiout.dig_out_nid = CXT5045_SPDIF_OUT;
1063 spec->num_adc_nids = 1;
1064 spec->adc_nids = cxt5045_adc_nids;
1065 spec->capsrc_nids = cxt5045_capsrc_nids;
1066 spec->input_mux = &cxt5045_capture_source;
1067 spec->num_mixers = 1;
1068 spec->mixers[0] = cxt5045_mixers;
1069 spec->num_init_verbs = 1;
1070 spec->init_verbs[0] = cxt5045_init_verbs;
1071 spec->spdif_route = 0;
3507e2a8
TI		 1072 spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes);
1073 spec->channel_mode = cxt5045_modes;
5cd57529 1074
3507e2a8 1075 set_beep_amp(spec, 0x16, 0, 1);
c9b443d4
TD		 1076
1077 codec->patch_ops = conexant_patch_ops;
c9b443d4 1078
c9b443d4 1079 switch (board_config) {
15908c36 1080 case CXT5045_LAPTOP_HPSENSE:
7f29673b
TD		 1081 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1082 spec->input_mux = &cxt5045_capture_source;
1083 spec->num_init_verbs = 2;
1084 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
1085 spec->mixers[0] = cxt5045_mixers;
1086 codec->patch_ops.init = cxt5045_init;
1087 break;
15908c36 1088 case CXT5045_LAPTOP_MICSENSE:
86376df6 1089 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
c9b443d4
TD		 1090 spec->input_mux = &cxt5045_capture_source;
1091 spec->num_init_verbs = 2;
7f29673b 1092 spec->init_verbs[1] = cxt5045_mic_sense_init_verbs;
c9b443d4
TD		 1093 spec->mixers[0] = cxt5045_mixers;
1094 codec->patch_ops.init = cxt5045_init;
1095 break;
15908c36
MB		 1096 default:
1097 case CXT5045_LAPTOP_HPMICSENSE:
1098 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1099 spec->input_mux = &cxt5045_capture_source;
1100 spec->num_init_verbs = 3;
1101 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
1102 spec->init_verbs[2] = cxt5045_mic_sense_init_verbs;
1103 spec->mixers[0] = cxt5045_mixers;
1104 codec->patch_ops.init = cxt5045_init;
1105 break;
5218c892
JZ		 1106 case CXT5045_BENQ:
1107 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1108 spec->input_mux = &cxt5045_capture_source_benq;
1109 spec->num_init_verbs = 1;
1110 spec->init_verbs[0] = cxt5045_benq_init_verbs;
1111 spec->mixers[0] = cxt5045_mixers;
1112 spec->mixers[1] = cxt5045_benq_mixers;
1113 spec->num_mixers = 2;
1114 codec->patch_ops.init = cxt5045_init;
1115 break;
2de3c232
J		 1116 case CXT5045_LAPTOP_HP530:
1117 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1118 spec->input_mux = &cxt5045_capture_source_hp530;
1119 spec->num_init_verbs = 2;
1120 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
1121 spec->mixers[0] = cxt5045_mixers_hp530;
1122 codec->patch_ops.init = cxt5045_init;
1123 break;
c9b443d4
TD		 1124#ifdef CONFIG_SND_DEBUG
1125 case CXT5045_TEST:
1126 spec->input_mux = &cxt5045_test_capture_source;
1127 spec->mixers[0] = cxt5045_test_mixer;
1128 spec->init_verbs[0] = cxt5045_test_init_verbs;
15908c36
MB		 1129 break;
1130
c9b443d4
TD		 1131#endif
1132 }
48ecb7e8 1133
031005f7
TI		 1134 switch (codec->subsystem_id >> 16) {
1135 case 0x103c:
8f0f5ff6 1136 case 0x1631:
0b587fc4 1137 case 0x1734:
0ebf9e36
DC		 1138 case 0x17aa:
1139 /* HP, Packard Bell, Fujitsu-Siemens & Lenovo laptops have
1140 * really bad sound over 0dB on NID 0x17. Fix max PCM level to
1141 * 0 dB (originally it has 0x2b steps with 0dB offset 0x14)
031005f7
TI		 1142 */
1143 snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT,
1144 (0x14 << AC_AMPCAP_OFFSET_SHIFT) |
1145 (0x14 << AC_AMPCAP_NUM_STEPS_SHIFT) |
1146 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
1147 (1 << AC_AMPCAP_MUTE_SHIFT));
1148 break;
1149 }
48ecb7e8 1150
3507e2a8 1151 if (spec->beep_amp)
a86b1a2c 1152 snd_hda_attach_beep_device(codec, get_amp_nid_(spec->beep_amp));
3507e2a8 1153
c9b443d4
TD		 1154 return 0;
1155}
1156
1157
1158/* Conexant 5047 specific */
82f30040 1159#define CXT5047_SPDIF_OUT 0x11
c9b443d4 1160
34cbe3a6
TI		 1161static const hda_nid_t cxt5047_dac_nids[1] = { 0x10 }; /* 0x1c */
1162static const hda_nid_t cxt5047_adc_nids[1] = { 0x12 };
1163static const hda_nid_t cxt5047_capsrc_nids[1] = { 0x1a };
c9b443d4 1164
34cbe3a6 1165static const struct hda_channel_mode cxt5047_modes[1] = {
5cd57529
TD		 1166 { 2, NULL },
1167};
c9b443d4 1168
34cbe3a6 1169static const struct hda_input_mux cxt5047_toshiba_capture_source = {
82f30040
TD		 1170 .num_items = 2,
1171 .items = {
1172 { "ExtMic", 0x2 },
1173 { "Line-In", 0x1 },
c9b443d4
TD		 1174 }
1175};
1176
1177/* turn on/off EAPD (+ mute HP) as a master switch */
1178static int cxt5047_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1179 struct snd_ctl_elem_value *ucontrol)
1180{
1181 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1182 struct conexant_spec *spec = codec->spec;
82f30040 1183 unsigned int bits;
c9b443d4 1184
82f30040 1185 if (!cxt_eapd_put(kcontrol, ucontrol))
c9b443d4
TD		 1186 return 0;
1187
82f30040
TD		 1188 /* toggle internal speakers mute depending of presence of
1189 * the headphone jack
1190 */
47fd830a 1191 bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE;
3b7523fc
TI		 1192 /* NOTE: Conexat codec needs the index for *OUTPUT* amp of
1193 * pin widgets unlike other codecs. In this case, we need to
1194 * set index 0x01 for the volume from the mixer amp 0x19.
1195 */
5d75bc55 1196 snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01,
47fd830a
TI		 1197 HDA_AMP_MUTE, bits);
1198 bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE;
1199 snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0,
1200 HDA_AMP_MUTE, bits);
c9b443d4
TD		 1201 return 1;
1202}
1203
c9b443d4
TD		 1204/* mute internal speaker if HP is plugged */
1205static void cxt5047_hp_automute(struct hda_codec *codec)
1206{
82f30040 1207 struct conexant_spec *spec = codec->spec;
dd87da1c 1208 unsigned int bits;
c9b443d4 1209
d56757ab 1210 spec->hp_present = snd_hda_jack_detect(codec, 0x13);
dd87da1c 1211
47fd830a 1212 bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
3b7523fc 1213 /* See the note in cxt5047_hp_master_sw_put */
5d75bc55 1214 snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01,
47fd830a 1215 HDA_AMP_MUTE, bits);
c9b443d4
TD		 1216}
1217
1218/* toggle input of built-in and mic jack appropriately */
1219static void cxt5047_hp_automic(struct hda_codec *codec)
1220{
34cbe3a6 1221 static const struct hda_verb mic_jack_on[] = {
9f113e0e
MB		 1222 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1223 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
c9b443d4
TD		 1224 {}
1225 };
34cbe3a6 1226 static const struct hda_verb mic_jack_off[] = {
9f113e0e
MB		 1227 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1228 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
c9b443d4
TD		 1229 {}
1230 };
1231 unsigned int present;
1232
d56757ab 1233 present = snd_hda_jack_detect(codec, 0x15);
c9b443d4
TD		 1234 if (present)
1235 snd_hda_sequence_write(codec, mic_jack_on);
1236 else
1237 snd_hda_sequence_write(codec, mic_jack_off);
1238}
1239
1240/* unsolicited event for HP jack sensing */
1241static void cxt5047_hp_unsol_event(struct hda_codec *codec,
1242 unsigned int res)
1243{
9f113e0e 1244 switch (res >> 26) {
c9b443d4
TD		 1245 case CONEXANT_HP_EVENT:
1246 cxt5047_hp_automute(codec);
1247 break;
1248 case CONEXANT_MIC_EVENT:
1249 cxt5047_hp_automic(codec);
1250 break;
1251 }
1252}
1253
34cbe3a6 1254static const struct snd_kcontrol_new cxt5047_base_mixers[] = {
df481e41
TI		 1255 HDA_CODEC_VOLUME("Mic Playback Volume", 0x19, 0x02, HDA_INPUT),
1256 HDA_CODEC_MUTE("Mic Playback Switch", 0x19, 0x02, HDA_INPUT),
5f99f86a 1257 HDA_CODEC_VOLUME("Mic Boost Volume", 0x1a, 0x0, HDA_OUTPUT),
c9b443d4
TD		 1258 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
1259 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
1260 HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
1261 HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
82f30040
TD		 1262 {
1263 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1264 .name = "Master Playback Switch",
1265 .info = cxt_eapd_info,
1266 .get = cxt_eapd_get,
c9b443d4
TD		 1267 .put = cxt5047_hp_master_sw_put,
1268 .private_value = 0x13,
1269 },
1270
1271 {}
1272};
1273
34cbe3a6 1274static const struct snd_kcontrol_new cxt5047_hp_spk_mixers[] = {
3b7523fc 1275 /* See the note in cxt5047_hp_master_sw_put */
5d75bc55 1276 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x01, HDA_OUTPUT),
df481e41
TI		 1277 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x13, 0x00, HDA_OUTPUT),
1278 {}
1279};
1280
34cbe3a6 1281static const struct snd_kcontrol_new cxt5047_hp_only_mixers[] = {
c9b443d4 1282 HDA_CODEC_VOLUME("Master Playback Volume", 0x13, 0x00, HDA_OUTPUT),
c9b443d4
TD		 1283 { } /* end */
1284};
1285
34cbe3a6 1286static const struct hda_verb cxt5047_init_verbs[] = {
c9b443d4
TD		 1287 /* Line in, Mic, Built-in Mic */
1288 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1289 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 },
1290 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 },
7f29673b 1291 /* HP, Speaker */
b7589ceb 1292 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
5b3a7440
TI		 1293 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, /* mixer(0x19) */
1294 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mixer(0x19) */
7f29673b 1295 /* Record selector: Mic */
c9b443d4
TD		 1296 {0x12, AC_VERB_SET_CONNECT_SEL,0x03},
1297 {0x19, AC_VERB_SET_AMP_GAIN_MUTE,
1298 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
7f29673b
TD		 1299 {0x1A, AC_VERB_SET_CONNECT_SEL,0x02},
1300 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE,
1301 AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x00},
1302 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE,
1303 AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x03},
c9b443d4
TD		 1304 /* SPDIF route: PCM */
1305 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x0 },
82f30040
TD		 1306 /* Enable unsolicited events */
1307 {0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
1308 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
c9b443d4
TD		 1309 { } /* end */
1310};
1311
1312/* configuration for Toshiba Laptops */
34cbe3a6 1313static const struct hda_verb cxt5047_toshiba_init_verbs[] = {
3b628867 1314 {0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x0}, /* default off */
c9b443d4
TD		 1315 {}
1316};
1317
1318/* Test configuration for debugging, modelled after the ALC260 test
1319 * configuration.
1320 */
1321#ifdef CONFIG_SND_DEBUG
34cbe3a6 1322static const struct hda_input_mux cxt5047_test_capture_source = {
82f30040 1323 .num_items = 4,
c9b443d4 1324 .items = {
82f30040
TD		 1325 { "LINE1 pin", 0x0 },
1326 { "MIC1 pin", 0x1 },
1327 { "MIC2 pin", 0x2 },
1328 { "CD pin", 0x3 },
c9b443d4
TD		 1329 },
1330};
1331
34cbe3a6 1332static const struct snd_kcontrol_new cxt5047_test_mixer[] = {
c9b443d4
TD		 1333
1334 /* Output only controls */
82f30040
TD		 1335 HDA_CODEC_VOLUME("OutAmp-1 Volume", 0x10, 0x0, HDA_OUTPUT),
1336 HDA_CODEC_MUTE("OutAmp-1 Switch", 0x10,0x0, HDA_OUTPUT),
1337 HDA_CODEC_VOLUME("OutAmp-2 Volume", 0x1c, 0x0, HDA_OUTPUT),
1338 HDA_CODEC_MUTE("OutAmp-2 Switch", 0x1c, 0x0, HDA_OUTPUT),
c9b443d4
TD		 1339 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1340 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1341 HDA_CODEC_VOLUME("HeadPhone Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1342 HDA_CODEC_MUTE("HeadPhone Playback Switch", 0x13, 0x0, HDA_OUTPUT),
82f30040
TD		 1343 HDA_CODEC_VOLUME("Line1-Out Playback Volume", 0x14, 0x0, HDA_OUTPUT),
1344 HDA_CODEC_MUTE("Line1-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1345 HDA_CODEC_VOLUME("Line2-Out Playback Volume", 0x15, 0x0, HDA_OUTPUT),
1346 HDA_CODEC_MUTE("Line2-Out Playback Switch", 0x15, 0x0, HDA_OUTPUT),
c9b443d4
TD		 1347
1348 /* Modes for retasking pin widgets */
1349 CXT_PIN_MODE("LINE1 pin mode", 0x14, CXT_PIN_DIR_INOUT),
1350 CXT_PIN_MODE("MIC1 pin mode", 0x15, CXT_PIN_DIR_INOUT),
1351
82f30040
TD		 1352 /* EAPD Switch Control */
1353 CXT_EAPD_SWITCH("External Amplifier", 0x13, 0x0),
c9b443d4 1354
82f30040
TD		 1355 /* Loopback mixer controls */
1356 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x12, 0x01, HDA_INPUT),
1357 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x12, 0x01, HDA_INPUT),
1358 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x12, 0x02, HDA_INPUT),
1359 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x12, 0x02, HDA_INPUT),
1360 HDA_CODEC_VOLUME("LINE Playback Volume", 0x12, 0x0, HDA_INPUT),
1361 HDA_CODEC_MUTE("LINE Playback Switch", 0x12, 0x0, HDA_INPUT),
1362 HDA_CODEC_VOLUME("CD Playback Volume", 0x12, 0x04, HDA_INPUT),
1363 HDA_CODEC_MUTE("CD Playback Switch", 0x12, 0x04, HDA_INPUT),
1364
1365 HDA_CODEC_VOLUME("Capture-1 Volume", 0x19, 0x0, HDA_INPUT),
1366 HDA_CODEC_MUTE("Capture-1 Switch", 0x19, 0x0, HDA_INPUT),
1367 HDA_CODEC_VOLUME("Capture-2 Volume", 0x19, 0x1, HDA_INPUT),
1368 HDA_CODEC_MUTE("Capture-2 Switch", 0x19, 0x1, HDA_INPUT),
1369 HDA_CODEC_VOLUME("Capture-3 Volume", 0x19, 0x2, HDA_INPUT),
1370 HDA_CODEC_MUTE("Capture-3 Switch", 0x19, 0x2, HDA_INPUT),
1371 HDA_CODEC_VOLUME("Capture-4 Volume", 0x19, 0x3, HDA_INPUT),
1372 HDA_CODEC_MUTE("Capture-4 Switch", 0x19, 0x3, HDA_INPUT),
c9b443d4
TD		 1373 {
1374 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1375 .name = "Input Source",
1376 .info = conexant_mux_enum_info,
1377 .get = conexant_mux_enum_get,
1378 .put = conexant_mux_enum_put,
1379 },
854206b0 1380 HDA_CODEC_VOLUME("Mic Boost Volume", 0x1a, 0x0, HDA_OUTPUT),
9f113e0e 1381
c9b443d4
TD		 1382 { } /* end */
1383};
1384
34cbe3a6 1385static const struct hda_verb cxt5047_test_init_verbs[] = {
c9b443d4
TD		 1386 /* Enable retasking pins as output, initially without power amp */
1387 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1388 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1389 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1390
1391 /* Disable digital (SPDIF) pins initially, but users can enable
1392 * them via a mixer switch. In the case of SPDIF-out, this initverb
1393 * payload also sets the generation to 0, output to be in "consumer"
1394 * PCM format, copyright asserted, no pre-emphasis and no validity
1395 * control.
1396 */
1397 {0x18, AC_VERB_SET_DIGI_CONVERT_1, 0},
1398
1399 /* Ensure mic1, mic2, line1 pin widgets take input from the
1400 * OUT1 sum bus when acting as an output.
1401 */
1402 {0x1a, AC_VERB_SET_CONNECT_SEL, 0},
1403 {0x1b, AC_VERB_SET_CONNECT_SEL, 0},
1404
1405 /* Start with output sum widgets muted and their output gains at min */
1406 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1407 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1408
1409 /* Unmute retasking pin widget output buffers since the default
1410 * state appears to be output. As the pin mode is changed by the
1411 * user the pin mode control will take care of enabling the pin's
1412 * input/output buffers as needed.
1413 */
1414 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1415 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1416 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1417
1418 /* Mute capture amp left and right */
1419 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1420
1421 /* Set ADC connection select to match default mixer setting (mic1
1422 * pin)
1423 */
1424 {0x12, AC_VERB_SET_CONNECT_SEL, 0x00},
1425
1426 /* Mute all inputs to mixer widget (even unconnected ones) */
1427 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
1428 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
1429 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
1430 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
1431 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
1432 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
1433 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
1434 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
1435
1436 { }
1437};
1438#endif
1439
1440
1441/* initialize jack-sensing, too */
1442static int cxt5047_hp_init(struct hda_codec *codec)
1443{
1444 conexant_init(codec);
1445 cxt5047_hp_automute(codec);
c9b443d4
TD		 1446 return 0;
1447}
1448
1449
1450enum {
f5fcc13c
TI		 1451 CXT5047_LAPTOP, /* Laptops w/o EAPD support */
1452 CXT5047_LAPTOP_HP, /* Some HP laptops */
1453 CXT5047_LAPTOP_EAPD, /* Laptops with EAPD support */
c9b443d4
TD		 1454#ifdef CONFIG_SND_DEBUG
1455 CXT5047_TEST,
1456#endif
fa5dadcb 1457 CXT5047_AUTO,
f5fcc13c 1458 CXT5047_MODELS
c9b443d4
TD		 1459};
1460
ea734963 1461static const char * const cxt5047_models[CXT5047_MODELS] = {
f5fcc13c
TI		 1462 [CXT5047_LAPTOP] = "laptop",
1463 [CXT5047_LAPTOP_HP] = "laptop-hp",
1464 [CXT5047_LAPTOP_EAPD] = "laptop-eapd",
c9b443d4 1465#ifdef CONFIG_SND_DEBUG
f5fcc13c 1466 [CXT5047_TEST] = "test",
c9b443d4 1467#endif
fa5dadcb 1468 [CXT5047_AUTO] = "auto",
f5fcc13c
TI		 1469};
1470
34cbe3a6 1471static const struct snd_pci_quirk cxt5047_cfg_tbl[] = {
ac3e3741 1472 SND_PCI_QUIRK(0x103c, 0x30a5, "HP DV5200T/DV8000T", CXT5047_LAPTOP_HP),
dea0a509
TI		 1473 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP DV Series",
1474 CXT5047_LAPTOP),
f5fcc13c 1475 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P100", CXT5047_LAPTOP_EAPD),
c9b443d4
TD		 1476 {}
1477};
1478
1479static int patch_cxt5047(struct hda_codec *codec)
1480{
1481 struct conexant_spec *spec;
1482 int board_config;
1483
fa5dadcb
TI		 1484 board_config = snd_hda_check_board_config(codec, CXT5047_MODELS,
1485 cxt5047_models,
1486 cxt5047_cfg_tbl);
fa5dadcb 1487 if (board_config < 0)
c82693db 1488 board_config = CXT5047_AUTO; /* model=auto as default */
fa5dadcb
TI		 1489 if (board_config == CXT5047_AUTO)
1490 return patch_conexant_auto(codec);
1491
c9b443d4
TD		 1492 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1493 if (!spec)
1494 return -ENOMEM;
c9b443d4 1495 codec->spec = spec;
9421f954 1496 codec->pin_amp_workaround = 1;
c9b443d4
TD		 1497
1498 spec->multiout.max_channels = 2;
1499 spec->multiout.num_dacs = ARRAY_SIZE(cxt5047_dac_nids);
1500 spec->multiout.dac_nids = cxt5047_dac_nids;
1501 spec->multiout.dig_out_nid = CXT5047_SPDIF_OUT;
1502 spec->num_adc_nids = 1;
1503 spec->adc_nids = cxt5047_adc_nids;
1504 spec->capsrc_nids = cxt5047_capsrc_nids;
c9b443d4 1505 spec->num_mixers = 1;
df481e41 1506 spec->mixers[0] = cxt5047_base_mixers;
c9b443d4
TD		 1507 spec->num_init_verbs = 1;
1508 spec->init_verbs[0] = cxt5047_init_verbs;
1509 spec->spdif_route = 0;
5cd57529
TD		 1510 spec->num_channel_mode = ARRAY_SIZE(cxt5047_modes),
1511 spec->channel_mode = cxt5047_modes,
c9b443d4
TD		 1512
1513 codec->patch_ops = conexant_patch_ops;
c9b443d4 1514
c9b443d4
TD		 1515 switch (board_config) {
1516 case CXT5047_LAPTOP:
df481e41
TI		 1517 spec->num_mixers = 2;
1518 spec->mixers[1] = cxt5047_hp_spk_mixers;
1519 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
c9b443d4
TD		 1520 break;
1521 case CXT5047_LAPTOP_HP:
df481e41
TI		 1522 spec->num_mixers = 2;
1523 spec->mixers[1] = cxt5047_hp_only_mixers;
fb3409e7 1524 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
c9b443d4
TD		 1525 codec->patch_ops.init = cxt5047_hp_init;
1526 break;
1527 case CXT5047_LAPTOP_EAPD:
82f30040 1528 spec->input_mux = &cxt5047_toshiba_capture_source;
df481e41
TI		 1529 spec->num_mixers = 2;
1530 spec->mixers[1] = cxt5047_hp_spk_mixers;
c9b443d4
TD		 1531 spec->num_init_verbs = 2;
1532 spec->init_verbs[1] = cxt5047_toshiba_init_verbs;
fb3409e7 1533 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
c9b443d4
TD		 1534 break;
1535#ifdef CONFIG_SND_DEBUG
1536 case CXT5047_TEST:
1537 spec->input_mux = &cxt5047_test_capture_source;
1538 spec->mixers[0] = cxt5047_test_mixer;
1539 spec->init_verbs[0] = cxt5047_test_init_verbs;
fb3409e7 1540 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
c9b443d4
TD		 1541#endif
1542 }
dd5746a8 1543 spec->vmaster_nid = 0x13;
025f206c
DC		 1544
1545 switch (codec->subsystem_id >> 16) {
1546 case 0x103c:
1547 /* HP laptops have really bad sound over 0 dB on NID 0x10.
1548 * Fix max PCM level to 0 dB (originally it has 0x1e steps
1549 * with 0 dB offset 0x17)
1550 */
1551 snd_hda_override_amp_caps(codec, 0x10, HDA_INPUT,
1552 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
1553 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
1554 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
1555 (1 << AC_AMPCAP_MUTE_SHIFT));
1556 break;
1557 }
1558
c9b443d4
TD		 1559 return 0;
1560}
1561
461e2c78 1562/* Conexant 5051 specific */
34cbe3a6
TI		 1563static const hda_nid_t cxt5051_dac_nids[1] = { 0x10 };
1564static const hda_nid_t cxt5051_adc_nids[2] = { 0x14, 0x15 };
461e2c78 1565
34cbe3a6 1566static const struct hda_channel_mode cxt5051_modes[1] = {
461e2c78
TI		 1567 { 2, NULL },
1568};
1569
1570static void cxt5051_update_speaker(struct hda_codec *codec)
1571{
1572 struct conexant_spec *spec = codec->spec;
1573 unsigned int pinctl;
23d2df5b
TI		 1574 /* headphone pin */
1575 pinctl = (spec->hp_present && spec->cur_eapd) ? PIN_HP : 0;
cdd03ced 1576 snd_hda_set_pin_ctl(codec, 0x16, pinctl);
23d2df5b 1577 /* speaker pin */
461e2c78 1578 pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
cdd03ced 1579 snd_hda_set_pin_ctl(codec, 0x1a, pinctl);
a80581d0 1580 /* on ideapad there is an additional speaker (subwoofer) to mute */
f7154de2 1581 if (spec->ideapad)
cdd03ced 1582 snd_hda_set_pin_ctl(codec, 0x1b, pinctl);
461e2c78
TI		 1583}
1584
1585/* turn on/off EAPD (+ mute HP) as a master switch */
1586static int cxt5051_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1587 struct snd_ctl_elem_value *ucontrol)
1588{
1589 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1590
1591 if (!cxt_eapd_put(kcontrol, ucontrol))
1592 return 0;
1593 cxt5051_update_speaker(codec);
1594 return 1;
1595}
1596
1597/* toggle input of built-in and mic jack appropriately */
1598static void cxt5051_portb_automic(struct hda_codec *codec)
1599{
79d7d533 1600 struct conexant_spec *spec = codec->spec;
461e2c78
TI		 1601 unsigned int present;
1602
faddaa5d 1603 if (!(spec->auto_mic & AUTO_MIC_PORTB))
79d7d533 1604 return;
d56757ab 1605 present = snd_hda_jack_detect(codec, 0x17);
461e2c78
TI		 1606 snd_hda_codec_write(codec, 0x14, 0,
1607 AC_VERB_SET_CONNECT_SEL,
1608 present ? 0x01 : 0x00);
1609}
1610
1611/* switch the current ADC according to the jack state */
1612static void cxt5051_portc_automic(struct hda_codec *codec)
1613{
1614 struct conexant_spec *spec = codec->spec;
1615 unsigned int present;
1616 hda_nid_t new_adc;
1617
faddaa5d 1618 if (!(spec->auto_mic & AUTO_MIC_PORTC))
79d7d533 1619 return;
d56757ab 1620 present = snd_hda_jack_detect(codec, 0x18);
461e2c78
TI		 1621 if (present)
1622 spec->cur_adc_idx = 1;
1623 else
1624 spec->cur_adc_idx = 0;
1625 new_adc = spec->adc_nids[spec->cur_adc_idx];
1626 if (spec->cur_adc && spec->cur_adc != new_adc) {
1627 /* stream is running, let's swap the current ADC */
f0cea797 1628 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
461e2c78
TI		 1629 spec->cur_adc = new_adc;
1630 snd_hda_codec_setup_stream(codec, new_adc,
1631 spec->cur_adc_stream_tag, 0,
1632 spec->cur_adc_format);
1633 }
1634}
1635
1636/* mute internal speaker if HP is plugged */
1637static void cxt5051_hp_automute(struct hda_codec *codec)
1638{
1639 struct conexant_spec *spec = codec->spec;
1640
d56757ab 1641 spec->hp_present = snd_hda_jack_detect(codec, 0x16);
461e2c78
TI		 1642 cxt5051_update_speaker(codec);
1643}
1644
1645/* unsolicited event for HP jack sensing */
1646static void cxt5051_hp_unsol_event(struct hda_codec *codec,
1647 unsigned int res)
1648{
1649 switch (res >> 26) {
1650 case CONEXANT_HP_EVENT:
1651 cxt5051_hp_automute(codec);
1652 break;
1653 case CXT5051_PORTB_EVENT:
1654 cxt5051_portb_automic(codec);
1655 break;
1656 case CXT5051_PORTC_EVENT:
1657 cxt5051_portc_automic(codec);
1658 break;
1659 }
1660}
1661
34cbe3a6 1662static const struct snd_kcontrol_new cxt5051_playback_mixers[] = {
461e2c78
TI		 1663 HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
1664 {
1665 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1666 .name = "Master Playback Switch",
1667 .info = cxt_eapd_info,
1668 .get = cxt_eapd_get,
1669 .put = cxt5051_hp_master_sw_put,
1670 .private_value = 0x1a,
1671 },
2c7a3fb3
TI		 1672 {}
1673};
461e2c78 1674
34cbe3a6 1675static const struct snd_kcontrol_new cxt5051_capture_mixers[] = {
2c7a3fb3
TI		 1676 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
1677 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
8607f7c4
DH		 1678 HDA_CODEC_VOLUME("Mic Volume", 0x14, 0x01, HDA_INPUT),
1679 HDA_CODEC_MUTE("Mic Switch", 0x14, 0x01, HDA_INPUT),
c40bd914
DH		 1680 HDA_CODEC_VOLUME("Dock Mic Volume", 0x15, 0x00, HDA_INPUT),
1681 HDA_CODEC_MUTE("Dock Mic Switch", 0x15, 0x00, HDA_INPUT),
461e2c78
TI		 1682 {}
1683};
1684
34cbe3a6 1685static const struct snd_kcontrol_new cxt5051_hp_mixers[] = {
461e2c78
TI		 1686 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
1687 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
8607f7c4
DH		 1688 HDA_CODEC_VOLUME("Mic Volume", 0x15, 0x00, HDA_INPUT),
1689 HDA_CODEC_MUTE("Mic Switch", 0x15, 0x00, HDA_INPUT),
461e2c78
TI		 1690 {}
1691};
1692
34cbe3a6 1693static const struct snd_kcontrol_new cxt5051_hp_dv6736_mixers[] = {
4e4ac600
TI		 1694 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x00, HDA_INPUT),
1695 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x00, HDA_INPUT),
79d7d533
TI		 1696 {}
1697};
1698
34cbe3a6 1699static const struct snd_kcontrol_new cxt5051_f700_mixers[] = {
5f6c3de6
TI		 1700 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x01, HDA_INPUT),
1701 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x01, HDA_INPUT),
cd9d95a5
KP		 1702 {}
1703};
1704
34cbe3a6 1705static const struct snd_kcontrol_new cxt5051_toshiba_mixers[] = {
faddaa5d
TI		 1706 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
1707 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
8607f7c4
DH		 1708 HDA_CODEC_VOLUME("Mic Volume", 0x14, 0x01, HDA_INPUT),
1709 HDA_CODEC_MUTE("Mic Switch", 0x14, 0x01, HDA_INPUT),
faddaa5d
TI		 1710 {}
1711};
1712
34cbe3a6 1713static const struct hda_verb cxt5051_init_verbs[] = {
461e2c78
TI		 1714 /* Line in, Mic */
1715 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1716 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1717 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1718 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1719 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1720 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1721 /* SPK */
1722 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1723 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
1724 /* HP, Amp */
1725 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1726 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
1727 /* DAC1 */
1728 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
28c4edb7 1729 /* Record selector: Internal mic */
461e2c78
TI		 1730 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
1731 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
1732 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
1733 /* SPDIF route: PCM */
1965c441 1734 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
461e2c78
TI		 1735 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
1736 /* EAPD */
1737 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
1738 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
461e2c78
TI		 1739 { } /* end */
1740};
1741
34cbe3a6 1742static const struct hda_verb cxt5051_hp_dv6736_init_verbs[] = {
79d7d533
TI		 1743 /* Line in, Mic */
1744 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1745 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1746 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
1747 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
1748 /* SPK */
1749 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1750 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
1751 /* HP, Amp */
1752 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1753 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
1754 /* DAC1 */
1755 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
28c4edb7 1756 /* Record selector: Internal mic */
79d7d533
TI		 1757 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
1758 {0x14, AC_VERB_SET_CONNECT_SEL, 0x1},
1759 /* SPDIF route: PCM */
1760 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
1761 /* EAPD */
1762 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
1763 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
79d7d533
TI		 1764 { } /* end */
1765};
1766
34cbe3a6 1767static const struct hda_verb cxt5051_f700_init_verbs[] = {
cd9d95a5 1768 /* Line in, Mic */
30ed7ed1 1769 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
cd9d95a5
KP		 1770 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1771 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
1772 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
1773 /* SPK */
1774 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1775 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
1776 /* HP, Amp */
1777 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1778 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
1779 /* DAC1 */
1780 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
28c4edb7 1781 /* Record selector: Internal mic */
cd9d95a5
KP		 1782 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
1783 {0x14, AC_VERB_SET_CONNECT_SEL, 0x1},
1784 /* SPDIF route: PCM */
1785 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
1786 /* EAPD */
1787 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
1788 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
cd9d95a5
KP		 1789 { } /* end */
1790};
1791
6953e552
TI		 1792static void cxt5051_init_mic_port(struct hda_codec *codec, hda_nid_t nid,
1793 unsigned int event)
1794{
1795 snd_hda_codec_write(codec, nid, 0,
1796 AC_VERB_SET_UNSOLICITED_ENABLE,
1797 AC_USRSP_EN | event);
6953e552
TI		 1798}
1799
34cbe3a6 1800static const struct hda_verb cxt5051_ideapad_init_verbs[] = {
f7154de2
HRK		 1801 /* Subwoofer */
1802 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1803 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1804 { } /* end */
1805};
1806
461e2c78
TI		 1807/* initialize jack-sensing, too */
1808static int cxt5051_init(struct hda_codec *codec)
1809{
6953e552
TI		 1810 struct conexant_spec *spec = codec->spec;
1811
461e2c78 1812 conexant_init(codec);
6953e552
TI		 1813
1814 if (spec->auto_mic & AUTO_MIC_PORTB)
1815 cxt5051_init_mic_port(codec, 0x17, CXT5051_PORTB_EVENT);
1816 if (spec->auto_mic & AUTO_MIC_PORTC)
1817 cxt5051_init_mic_port(codec, 0x18, CXT5051_PORTC_EVENT);
1818
461e2c78
TI		 1819 if (codec->patch_ops.unsol_event) {
1820 cxt5051_hp_automute(codec);
1821 cxt5051_portb_automic(codec);
1822 cxt5051_portc_automic(codec);
1823 }
1824 return 0;
1825}
1826
1827
1828enum {
1829 CXT5051_LAPTOP, /* Laptops w/ EAPD support */
1830 CXT5051_HP, /* no docking */
79d7d533 1831 CXT5051_HP_DV6736, /* HP without mic switch */
cd9d95a5 1832 CXT5051_F700, /* HP Compaq Presario F700 */
faddaa5d 1833 CXT5051_TOSHIBA, /* Toshiba M300 & co */
f7154de2 1834 CXT5051_IDEAPAD, /* Lenovo IdeaPad Y430 */
6764bcef 1835 CXT5051_AUTO, /* auto-parser */
461e2c78
TI		 1836 CXT5051_MODELS
1837};
1838
ea734963 1839static const char *const cxt5051_models[CXT5051_MODELS] = {
461e2c78
TI		 1840 [CXT5051_LAPTOP] = "laptop",
1841 [CXT5051_HP] = "hp",
79d7d533 1842 [CXT5051_HP_DV6736] = "hp-dv6736",
5f6c3de6 1843 [CXT5051_F700] = "hp-700",
faddaa5d 1844 [CXT5051_TOSHIBA] = "toshiba",
f7154de2 1845 [CXT5051_IDEAPAD] = "ideapad",
6764bcef 1846 [CXT5051_AUTO] = "auto",
461e2c78
TI		 1847};
1848
34cbe3a6 1849static const struct snd_pci_quirk cxt5051_cfg_tbl[] = {
79d7d533 1850 SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV6736", CXT5051_HP_DV6736),
1812e67c 1851 SND_PCI_QUIRK(0x103c, 0x360b, "Compaq Presario CQ60", CXT5051_HP),
5f6c3de6 1852 SND_PCI_QUIRK(0x103c, 0x30ea, "Compaq Presario F700", CXT5051_F700),
faddaa5d 1853 SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba M30x", CXT5051_TOSHIBA),
461e2c78
TI		 1854 SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
1855 CXT5051_LAPTOP),
1856 SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
f7154de2 1857 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo IdeaPad", CXT5051_IDEAPAD),
461e2c78
TI		 1858 {}
1859};
1860
1861static int patch_cxt5051(struct hda_codec *codec)
1862{
1863 struct conexant_spec *spec;
1864 int board_config;
1865
6764bcef
TI		 1866 board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
1867 cxt5051_models,
1868 cxt5051_cfg_tbl);
1869 if (board_config < 0)
c82693db 1870 board_config = CXT5051_AUTO; /* model=auto as default */
1f8458a2 1871 if (board_config == CXT5051_AUTO)
6764bcef 1872 return patch_conexant_auto(codec);
6764bcef 1873
461e2c78
TI		 1874 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1875 if (!spec)
1876 return -ENOMEM;
461e2c78 1877 codec->spec = spec;
9421f954 1878 codec->pin_amp_workaround = 1;
461e2c78
TI		 1879
1880 codec->patch_ops = conexant_patch_ops;
1881 codec->patch_ops.init = cxt5051_init;
1882
1883 spec->multiout.max_channels = 2;
1884 spec->multiout.num_dacs = ARRAY_SIZE(cxt5051_dac_nids);
1885 spec->multiout.dac_nids = cxt5051_dac_nids;
1886 spec->multiout.dig_out_nid = CXT5051_SPDIF_OUT;
1887 spec->num_adc_nids = 1; /* not 2; via auto-mic switch */
1888 spec->adc_nids = cxt5051_adc_nids;
2c7a3fb3
TI		 1889 spec->num_mixers = 2;
1890 spec->mixers[0] = cxt5051_capture_mixers;
1891 spec->mixers[1] = cxt5051_playback_mixers;
461e2c78
TI		 1892 spec->num_init_verbs = 1;
1893 spec->init_verbs[0] = cxt5051_init_verbs;
1894 spec->spdif_route = 0;
1895 spec->num_channel_mode = ARRAY_SIZE(cxt5051_modes);
1896 spec->channel_mode = cxt5051_modes;
1897 spec->cur_adc = 0;
1898 spec->cur_adc_idx = 0;
1899
3507e2a8
TI		 1900 set_beep_amp(spec, 0x13, 0, HDA_OUTPUT);
1901
79d7d533
TI		 1902 codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
1903
faddaa5d 1904 spec->auto_mic = AUTO_MIC_PORTB | AUTO_MIC_PORTC;
461e2c78
TI		 1905 switch (board_config) {
1906 case CXT5051_HP:
461e2c78
TI		 1907 spec->mixers[0] = cxt5051_hp_mixers;
1908 break;
79d7d533
TI		 1909 case CXT5051_HP_DV6736:
1910 spec->init_verbs[0] = cxt5051_hp_dv6736_init_verbs;
1911 spec->mixers[0] = cxt5051_hp_dv6736_mixers;
faddaa5d 1912 spec->auto_mic = 0;
79d7d533 1913 break;
cd9d95a5
KP		 1914 case CXT5051_F700:
1915 spec->init_verbs[0] = cxt5051_f700_init_verbs;
1916 spec->mixers[0] = cxt5051_f700_mixers;
faddaa5d
TI		 1917 spec->auto_mic = 0;
1918 break;
1919 case CXT5051_TOSHIBA:
1920 spec->mixers[0] = cxt5051_toshiba_mixers;
1921 spec->auto_mic = AUTO_MIC_PORTB;
cd9d95a5 1922 break;
f7154de2
HRK		 1923 case CXT5051_IDEAPAD:
1924 spec->init_verbs[spec->num_init_verbs++] =
1925 cxt5051_ideapad_init_verbs;
1926 spec->ideapad = 1;
1927 break;
461e2c78
TI		 1928 }
1929
3507e2a8 1930 if (spec->beep_amp)
a86b1a2c 1931 snd_hda_attach_beep_device(codec, get_amp_nid_(spec->beep_amp));
3507e2a8 1932
461e2c78
TI		 1933 return 0;
1934}
1935
0fb67e98
DD		 1936/* Conexant 5066 specific */
1937
34cbe3a6
TI		 1938static const hda_nid_t cxt5066_dac_nids[1] = { 0x10 };
1939static const hda_nid_t cxt5066_adc_nids[3] = { 0x14, 0x15, 0x16 };
1940static const hda_nid_t cxt5066_capsrc_nids[1] = { 0x17 };
1941static const hda_nid_t cxt5066_digout_pin_nids[2] = { 0x20, 0x22 };
0fb67e98 1942
dbaccc0c
DD		 1943/* OLPC's microphone port is DC coupled for use with external sensors,
1944 * therefore we use a 50% mic bias in order to center the input signal with
1945 * the DC input range of the codec. */
1946#define CXT5066_OLPC_EXT_MIC_BIAS PIN_VREF50
1947
34cbe3a6 1948static const struct hda_channel_mode cxt5066_modes[1] = {
0fb67e98
DD		 1949 { 2, NULL },
1950};
1951
a3de8ab8
TI		 1952#define HP_PRESENT_PORT_A (1 << 0)
1953#define HP_PRESENT_PORT_D (1 << 1)
1954#define hp_port_a_present(spec) ((spec)->hp_present & HP_PRESENT_PORT_A)
1955#define hp_port_d_present(spec) ((spec)->hp_present & HP_PRESENT_PORT_D)
1956
0fb67e98
DD		 1957static void cxt5066_update_speaker(struct hda_codec *codec)
1958{
1959 struct conexant_spec *spec = codec->spec;
1960 unsigned int pinctl;
1961
3a253445
JB		 1962 snd_printdd("CXT5066: update speaker, hp_present=%d, cur_eapd=%d\n",
1963 spec->hp_present, spec->cur_eapd);
0fb67e98
DD		 1964
1965 /* Port A (HP) */
a3de8ab8 1966 pinctl = (hp_port_a_present(spec) && spec->cur_eapd) ? PIN_HP : 0;
cdd03ced 1967 snd_hda_set_pin_ctl(codec, 0x19, pinctl);
0fb67e98
DD		 1968
1969 /* Port D (HP/LO) */
a3de8ab8
TI		 1970 pinctl = spec->cur_eapd ? spec->port_d_mode : 0;
1971 if (spec->dell_automute || spec->thinkpad) {
1972 /* Mute if Port A is connected */
1973 if (hp_port_a_present(spec))
3a253445
JB		 1974 pinctl = 0;
1975 } else {
a3de8ab8
TI		 1976 /* Thinkpad/Dell doesn't give pin-D status */
1977 if (!hp_port_d_present(spec))
1978 pinctl = 0;
3a253445 1979 }
cdd03ced 1980 snd_hda_set_pin_ctl(codec, 0x1c, pinctl);
0fb67e98
DD		 1981
1982 /* CLASS_D AMP */
1983 pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
cdd03ced 1984 snd_hda_set_pin_ctl(codec, 0x1f, pinctl);
0fb67e98
DD		 1985}
1986
1987/* turn on/off EAPD (+ mute HP) as a master switch */
1988static int cxt5066_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1989 struct snd_ctl_elem_value *ucontrol)
1990{
1991 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1992
1993 if (!cxt_eapd_put(kcontrol, ucontrol))
1994 return 0;
1995
1996 cxt5066_update_speaker(codec);
1997 return 1;
1998}
1999
c4cfe66c
DD		 2000static const struct hda_input_mux cxt5066_olpc_dc_bias = {
2001 .num_items = 3,
2002 .items = {
2003 { "Off", PIN_IN },
2004 { "50%", PIN_VREF50 },
2005 { "80%", PIN_VREF80 },
2006 },
2007};
2008
2009static int cxt5066_set_olpc_dc_bias(struct hda_codec *codec)
2010{
2011 struct conexant_spec *spec = codec->spec;
2012 /* Even though port F is the DC input, the bias is controlled on port B.
2013 * we also leave that port as an active input (but unselected) in DC mode
2014 * just in case that is necessary to make the bias setting take effect. */
cdd03ced 2015 return snd_hda_set_pin_ctl_cache(codec, 0x1a,
c4cfe66c
DD		 2016 cxt5066_olpc_dc_bias.items[spec->dc_input_bias].index);
2017}
2018
75f8991d
DD		 2019/* OLPC defers mic widget control until when capture is started because the
2020 * microphone LED comes on as soon as these settings are put in place. if we
2021 * did this before recording, it would give the false indication that recording
2022 * is happening when it is not. */
2023static void cxt5066_olpc_select_mic(struct hda_codec *codec)
0fb67e98 2024{
dbaccc0c 2025 struct conexant_spec *spec = codec->spec;
75f8991d
DD		 2026 if (!spec->recording)
2027 return;
0fb67e98 2028
c4cfe66c
DD		 2029 if (spec->dc_enable) {
2030 /* in DC mode we ignore presence detection and just use the jack
2031 * through our special DC port */
2032 const struct hda_verb enable_dc_mode[] = {
2033 /* disble internal mic, port C */
2034 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2035
2036 /* enable DC capture, port F */
2037 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2038 {},
2039 };
2040
2041 snd_hda_sequence_write(codec, enable_dc_mode);
2042 /* port B input disabled (and bias set) through the following call */
2043 cxt5066_set_olpc_dc_bias(codec);
2044 return;
2045 }
2046
2047 /* disable DC (port F) */
cdd03ced 2048 snd_hda_set_pin_ctl(codec, 0x1e, 0);
c4cfe66c 2049
75f8991d 2050 /* external mic, port B */
cdd03ced 2051 snd_hda_set_pin_ctl(codec, 0x1a,
75f8991d 2052 spec->ext_mic_present ? CXT5066_OLPC_EXT_MIC_BIAS : 0);
0fb67e98 2053
75f8991d 2054 /* internal mic, port C */
cdd03ced 2055 snd_hda_set_pin_ctl(codec, 0x1b,
75f8991d
DD		 2056 spec->ext_mic_present ? 0 : PIN_VREF80);
2057}
0fb67e98 2058
75f8991d
DD		 2059/* toggle input of built-in and mic jack appropriately */
2060static void cxt5066_olpc_automic(struct hda_codec *codec)
2061{
2062 struct conexant_spec *spec = codec->spec;
0fb67e98
DD		 2063 unsigned int present;
2064
c4cfe66c
DD		 2065 if (spec->dc_enable) /* don't do presence detection in DC mode */
2066 return;
2067
75f8991d
DD		 2068 present = snd_hda_codec_read(codec, 0x1a, 0,
2069 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2070 if (present)
0fb67e98 2071 snd_printdd("CXT5066: external microphone detected\n");
75f8991d 2072 else
0fb67e98 2073 snd_printdd("CXT5066: external microphone absent\n");
75f8991d
DD		 2074
2075 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL,
2076 present ? 0 : 1);
2077 spec->ext_mic_present = !!present;
2078
2079 cxt5066_olpc_select_mic(codec);
0fb67e98
DD		 2080}
2081
95a618bd
ER		 2082/* toggle input of built-in digital mic and mic jack appropriately */
2083static void cxt5066_vostro_automic(struct hda_codec *codec)
2084{
95a618bd
ER		 2085 unsigned int present;
2086
2087 struct hda_verb ext_mic_present[] = {
2088 /* enable external mic, port B */
75f8991d 2089 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
95a618bd
ER		 2090
2091 /* switch to external mic input */
2092 {0x17, AC_VERB_SET_CONNECT_SEL, 0},
2093 {0x14, AC_VERB_SET_CONNECT_SEL, 0},
2094
2095 /* disable internal digital mic */
2096 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2097 {}
2098 };
34cbe3a6 2099 static const struct hda_verb ext_mic_absent[] = {
95a618bd
ER		 2100 /* enable internal mic, port C */
2101 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2102
2103 /* switch to internal mic input */
2104 {0x14, AC_VERB_SET_CONNECT_SEL, 2},
2105
2106 /* disable external mic, port B */
2107 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2108 {}
2109 };
2110
2111 present = snd_hda_jack_detect(codec, 0x1a);
2112 if (present) {
2113 snd_printdd("CXT5066: external microphone detected\n");
2114 snd_hda_sequence_write(codec, ext_mic_present);
2115 } else {
2116 snd_printdd("CXT5066: external microphone absent\n");
2117 snd_hda_sequence_write(codec, ext_mic_absent);
2118 }
2119}
2120
cfd3d8dc
GA		 2121/* toggle input of built-in digital mic and mic jack appropriately */
2122static void cxt5066_ideapad_automic(struct hda_codec *codec)
2123{
2124 unsigned int present;
2125
2126 struct hda_verb ext_mic_present[] = {
2127 {0x14, AC_VERB_SET_CONNECT_SEL, 0},
2128 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2129 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2130 {}
2131 };
34cbe3a6 2132 static const struct hda_verb ext_mic_absent[] = {
cfd3d8dc
GA		 2133 {0x14, AC_VERB_SET_CONNECT_SEL, 2},
2134 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2135 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2136 {}
2137 };
2138
2139 present = snd_hda_jack_detect(codec, 0x1b);
2140 if (present) {
2141 snd_printdd("CXT5066: external microphone detected\n");
2142 snd_hda_sequence_write(codec, ext_mic_present);
2143 } else {
2144 snd_printdd("CXT5066: external microphone absent\n");
2145 snd_hda_sequence_write(codec, ext_mic_absent);
2146 }
2147}
2148
a1d6906e
DH		 2149
2150/* toggle input of built-in digital mic and mic jack appropriately */
2151static void cxt5066_asus_automic(struct hda_codec *codec)
2152{
2153 unsigned int present;
2154
2155 present = snd_hda_jack_detect(codec, 0x1b);
2156 snd_printdd("CXT5066: external microphone present=%d\n", present);
2157 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL,
2158 present ? 1 : 0);
2159}
2160
2161
048e78a5
DH		 2162/* toggle input of built-in digital mic and mic jack appropriately */
2163static void cxt5066_hp_laptop_automic(struct hda_codec *codec)
2164{
2165 unsigned int present;
2166
2167 present = snd_hda_jack_detect(codec, 0x1b);
2168 snd_printdd("CXT5066: external microphone present=%d\n", present);
2169 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL,
2170 present ? 1 : 3);
2171}
2172
2173
7b2bfdbc
JT		 2174/* toggle input of built-in digital mic and mic jack appropriately
2175 order is: external mic -> dock mic -> interal mic */
2176static void cxt5066_thinkpad_automic(struct hda_codec *codec)
2177{
2178 unsigned int ext_present, dock_present;
2179
34cbe3a6 2180 static const struct hda_verb ext_mic_present[] = {
7b2bfdbc
JT		 2181 {0x14, AC_VERB_SET_CONNECT_SEL, 0},
2182 {0x17, AC_VERB_SET_CONNECT_SEL, 1},
2183 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2184 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2185 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2186 {}
2187 };
34cbe3a6 2188 static const struct hda_verb dock_mic_present[] = {
7b2bfdbc
JT		 2189 {0x14, AC_VERB_SET_CONNECT_SEL, 0},
2190 {0x17, AC_VERB_SET_CONNECT_SEL, 0},
2191 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2192 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2193 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2194 {}
2195 };
34cbe3a6 2196 static const struct hda_verb ext_mic_absent[] = {
7b2bfdbc
JT		 2197 {0x14, AC_VERB_SET_CONNECT_SEL, 2},
2198 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2199 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2200 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2201 {}
2202 };
2203
2204 ext_present = snd_hda_jack_detect(codec, 0x1b);
2205 dock_present = snd_hda_jack_detect(codec, 0x1a);
2206 if (ext_present) {
2207 snd_printdd("CXT5066: external microphone detected\n");
2208 snd_hda_sequence_write(codec, ext_mic_present);
2209 } else if (dock_present) {
2210 snd_printdd("CXT5066: dock microphone detected\n");
2211 snd_hda_sequence_write(codec, dock_mic_present);
2212 } else {
2213 snd_printdd("CXT5066: external microphone absent\n");
2214 snd_hda_sequence_write(codec, ext_mic_absent);
2215 }
2216}
2217
0fb67e98
DD		 2218/* mute internal speaker if HP is plugged */
2219static void cxt5066_hp_automute(struct hda_codec *codec)
2220{
2221 struct conexant_spec *spec = codec->spec;
2222 unsigned int portA, portD;
2223
2224 /* Port A */
d56757ab 2225 portA = snd_hda_jack_detect(codec, 0x19);
0fb67e98
DD		 2226
2227 /* Port D */
d56757ab 2228 portD = snd_hda_jack_detect(codec, 0x1c);
0fb67e98 2229
a3de8ab8
TI		 2230 spec->hp_present = portA ? HP_PRESENT_PORT_A : 0;
2231 spec->hp_present |= portD ? HP_PRESENT_PORT_D : 0;
0fb67e98
DD		 2232 snd_printdd("CXT5066: hp automute portA=%x portD=%x present=%d\n",
2233 portA, portD, spec->hp_present);
2234 cxt5066_update_speaker(codec);
2235}
2236
02b6b5b6
DH		 2237/* Dispatch the right mic autoswitch function */
2238static void cxt5066_automic(struct hda_codec *codec)
0fb67e98 2239{
c4cfe66c 2240 struct conexant_spec *spec = codec->spec;
0fb67e98 2241
02b6b5b6 2242 if (spec->dell_vostro)
95a618bd 2243 cxt5066_vostro_automic(codec);
02b6b5b6 2244 else if (spec->ideapad)
cfd3d8dc 2245 cxt5066_ideapad_automic(codec);
02b6b5b6
DH		 2246 else if (spec->thinkpad)
2247 cxt5066_thinkpad_automic(codec);
2248 else if (spec->hp_laptop)
2249 cxt5066_hp_laptop_automic(codec);
a1d6906e
DH		 2250 else if (spec->asus)
2251 cxt5066_asus_automic(codec);
cfd3d8dc
GA		 2252}
2253
048e78a5 2254/* unsolicited event for jack sensing */
02b6b5b6 2255static void cxt5066_olpc_unsol_event(struct hda_codec *codec, unsigned int res)
048e78a5 2256{
02b6b5b6
DH		 2257 struct conexant_spec *spec = codec->spec;
2258 snd_printdd("CXT5066: unsol event %x (%x)\n", res, res >> 26);
048e78a5
DH		 2259 switch (res >> 26) {
2260 case CONEXANT_HP_EVENT:
2261 cxt5066_hp_automute(codec);
2262 break;
2263 case CONEXANT_MIC_EVENT:
02b6b5b6
DH		 2264 /* ignore mic events in DC mode; we're always using the jack */
2265 if (!spec->dc_enable)
2266 cxt5066_olpc_automic(codec);
048e78a5
DH		 2267 break;
2268 }
2269}
2270
7b2bfdbc 2271/* unsolicited event for jack sensing */
02b6b5b6 2272static void cxt5066_unsol_event(struct hda_codec *codec, unsigned int res)
7b2bfdbc 2273{
02b6b5b6 2274 snd_printdd("CXT5066: unsol event %x (%x)\n", res, res >> 26);
7b2bfdbc
JT		 2275 switch (res >> 26) {
2276 case CONEXANT_HP_EVENT:
2277 cxt5066_hp_automute(codec);
2278 break;
2279 case CONEXANT_MIC_EVENT:
02b6b5b6 2280 cxt5066_automic(codec);
7b2bfdbc
JT		 2281 break;
2282 }
2283}
2284
02b6b5b6 2285
0fb67e98
DD		 2286static const struct hda_input_mux cxt5066_analog_mic_boost = {
2287 .num_items = 5,
2288 .items = {
2289 { "0dB", 0 },
2290 { "10dB", 1 },
2291 { "20dB", 2 },
2292 { "30dB", 3 },
2293 { "40dB", 4 },
2294 },
2295};
2296
cfd3d8dc 2297static void cxt5066_set_mic_boost(struct hda_codec *codec)
c4cfe66c
DD		 2298{
2299 struct conexant_spec *spec = codec->spec;
cfd3d8dc 2300 snd_hda_codec_write_cache(codec, 0x17, 0,
c4cfe66c
DD		 2301 AC_VERB_SET_AMP_GAIN_MUTE,
2302 AC_AMP_SET_RIGHT | AC_AMP_SET_LEFT | AC_AMP_SET_OUTPUT |
2303 cxt5066_analog_mic_boost.items[spec->mic_boost].index);
7b2bfdbc 2304 if (spec->ideapad || spec->thinkpad) {
cfd3d8dc
GA		 2305 /* adjust the internal mic as well...it is not through 0x17 */
2306 snd_hda_codec_write_cache(codec, 0x23, 0,
2307 AC_VERB_SET_AMP_GAIN_MUTE,
2308 AC_AMP_SET_RIGHT | AC_AMP_SET_LEFT | AC_AMP_SET_INPUT |
2309 cxt5066_analog_mic_boost.
2310 items[spec->mic_boost].index);
2311 }
c4cfe66c
DD		 2312}
2313
0fb67e98
DD		 2314static int cxt5066_mic_boost_mux_enum_info(struct snd_kcontrol *kcontrol,
2315 struct snd_ctl_elem_info *uinfo)
2316{
2317 return snd_hda_input_mux_info(&cxt5066_analog_mic_boost, uinfo);
2318}
2319
2320static int cxt5066_mic_boost_mux_enum_get(struct snd_kcontrol *kcontrol,
2321 struct snd_ctl_elem_value *ucontrol)
2322{
2323 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
c4cfe66c
DD		 2324 struct conexant_spec *spec = codec->spec;
2325 ucontrol->value.enumerated.item[0] = spec->mic_boost;
0fb67e98
DD		 2326 return 0;
2327}
2328
2329static int cxt5066_mic_boost_mux_enum_put(struct snd_kcontrol *kcontrol,
2330 struct snd_ctl_elem_value *ucontrol)
2331{
2332 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
c4cfe66c 2333 struct conexant_spec *spec = codec->spec;
0fb67e98
DD		 2334 const struct hda_input_mux *imux = &cxt5066_analog_mic_boost;
2335 unsigned int idx;
c4cfe66c
DD		 2336 idx = ucontrol->value.enumerated.item[0];
2337 if (idx >= imux->num_items)
2338 idx = imux->num_items - 1;
2339
2340 spec->mic_boost = idx;
2341 if (!spec->dc_enable)
2342 cxt5066_set_mic_boost(codec);
2343 return 1;
2344}
2345
2346static void cxt5066_enable_dc(struct hda_codec *codec)
2347{
2348 const struct hda_verb enable_dc_mode[] = {
2349 /* disable gain */
2350 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2351
2352 /* switch to DC input */
2353 {0x17, AC_VERB_SET_CONNECT_SEL, 3},
2354 {}
2355 };
2356
2357 /* configure as input source */
2358 snd_hda_sequence_write(codec, enable_dc_mode);
2359 cxt5066_olpc_select_mic(codec); /* also sets configured bias */
2360}
2361
2362static void cxt5066_disable_dc(struct hda_codec *codec)
2363{
2364 /* reconfigure input source */
2365 cxt5066_set_mic_boost(codec);
2366 /* automic also selects the right mic if we're recording */
2367 cxt5066_olpc_automic(codec);
2368}
2369
2370static int cxt5066_olpc_dc_get(struct snd_kcontrol *kcontrol,
2371 struct snd_ctl_elem_value *ucontrol)
2372{
2373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2374 struct conexant_spec *spec = codec->spec;
2375 ucontrol->value.integer.value[0] = spec->dc_enable;
2376 return 0;
2377}
0fb67e98 2378
c4cfe66c
DD		 2379static int cxt5066_olpc_dc_put(struct snd_kcontrol *kcontrol,
2380 struct snd_ctl_elem_value *ucontrol)
2381{
2382 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2383 struct conexant_spec *spec = codec->spec;
2384 int dc_enable = !!ucontrol->value.integer.value[0];
2385
2386 if (dc_enable == spec->dc_enable)
0fb67e98 2387 return 0;
c4cfe66c
DD		 2388
2389 spec->dc_enable = dc_enable;
2390 if (dc_enable)
2391 cxt5066_enable_dc(codec);
2392 else
2393 cxt5066_disable_dc(codec);
2394
2395 return 1;
2396}
2397
2398static int cxt5066_olpc_dc_bias_enum_info(struct snd_kcontrol *kcontrol,
2399 struct snd_ctl_elem_info *uinfo)
2400{
2401 return snd_hda_input_mux_info(&cxt5066_olpc_dc_bias, uinfo);
2402}
2403
2404static int cxt5066_olpc_dc_bias_enum_get(struct snd_kcontrol *kcontrol,
2405 struct snd_ctl_elem_value *ucontrol)
2406{
2407 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2408 struct conexant_spec *spec = codec->spec;
2409 ucontrol->value.enumerated.item[0] = spec->dc_input_bias;
2410 return 0;
2411}
2412
2413static int cxt5066_olpc_dc_bias_enum_put(struct snd_kcontrol *kcontrol,
2414 struct snd_ctl_elem_value *ucontrol)
2415{
2416 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2417 struct conexant_spec *spec = codec->spec;
2418 const struct hda_input_mux *imux = &cxt5066_analog_mic_boost;
2419 unsigned int idx;
2420
0fb67e98
DD		 2421 idx = ucontrol->value.enumerated.item[0];
2422 if (idx >= imux->num_items)
2423 idx = imux->num_items - 1;
2424
c4cfe66c
DD		 2425 spec->dc_input_bias = idx;
2426 if (spec->dc_enable)
2427 cxt5066_set_olpc_dc_bias(codec);
0fb67e98
DD		 2428 return 1;
2429}
2430
75f8991d
DD		 2431static void cxt5066_olpc_capture_prepare(struct hda_codec *codec)
2432{
2433 struct conexant_spec *spec = codec->spec;
2434 /* mark as recording and configure the microphone widget so that the
2435 * recording LED comes on. */
2436 spec->recording = 1;
2437 cxt5066_olpc_select_mic(codec);
2438}
2439
2440static void cxt5066_olpc_capture_cleanup(struct hda_codec *codec)
2441{
2442 struct conexant_spec *spec = codec->spec;
2443 const struct hda_verb disable_mics[] = {
2444 /* disable external mic, port B */
2445 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2446
2447 /* disble internal mic, port C */
2448 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
c4cfe66c
DD		 2449
2450 /* disable DC capture, port F */
2451 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
75f8991d
DD		 2452 {},
2453 };
2454
2455 snd_hda_sequence_write(codec, disable_mics);
2456 spec->recording = 0;
2457}
2458
f6a2491c 2459static void conexant_check_dig_outs(struct hda_codec *codec,
34cbe3a6 2460 const hda_nid_t *dig_pins,
f6a2491c
AR		 2461 int num_pins)
2462{
2463 struct conexant_spec *spec = codec->spec;
2464 hda_nid_t *nid_loc = &spec->multiout.dig_out_nid;
2465 int i;
2466
2467 for (i = 0; i < num_pins; i++, dig_pins++) {
2468 unsigned int cfg = snd_hda_codec_get_pincfg(codec, *dig_pins);
2469 if (get_defcfg_connect(cfg) == AC_JACK_PORT_NONE)
2470 continue;
2471 if (snd_hda_get_connections(codec, *dig_pins, nid_loc, 1) != 1)
2472 continue;
f6a2491c
AR		 2473 }
2474}
2475
34cbe3a6 2476static const struct hda_input_mux cxt5066_capture_source = {
0fb67e98
DD		 2477 .num_items = 4,
2478 .items = {
2479 { "Mic B", 0 },
2480 { "Mic C", 1 },
2481 { "Mic E", 2 },
2482 { "Mic F", 3 },
2483 },
2484};
2485
34cbe3a6 2486static const struct hda_bind_ctls cxt5066_bind_capture_vol_others = {
0fb67e98
DD		 2487 .ops = &snd_hda_bind_vol,
2488 .values = {
2489 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_INPUT),
2490 HDA_COMPOSE_AMP_VAL(0x14, 3, 2, HDA_INPUT),
2491 0
2492 },
2493};
2494
34cbe3a6 2495static const struct hda_bind_ctls cxt5066_bind_capture_sw_others = {
0fb67e98
DD		 2496 .ops = &snd_hda_bind_sw,
2497 .values = {
2498 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_INPUT),
2499 HDA_COMPOSE_AMP_VAL(0x14, 3, 2, HDA_INPUT),
2500 0
2501 },
2502};
2503
34cbe3a6 2504static const struct snd_kcontrol_new cxt5066_mixer_master[] = {
0fb67e98
DD		 2505 HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
2506 {}
2507};
2508
34cbe3a6 2509static const struct snd_kcontrol_new cxt5066_mixer_master_olpc[] = {
0fb67e98
DD		 2510 {
2511 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2512 .name = "Master Playback Volume",
2513 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
2514 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2515 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,
5e26dfd0 2516 .subdevice = HDA_SUBDEV_AMP_FLAG,
0fb67e98
DD		 2517 .info = snd_hda_mixer_amp_volume_info,
2518 .get = snd_hda_mixer_amp_volume_get,
2519 .put = snd_hda_mixer_amp_volume_put,
2520 .tlv = { .c = snd_hda_mixer_amp_tlv },
2521 /* offset by 28 volume steps to limit minimum gain to -46dB */
2522 .private_value =
2523 HDA_COMPOSE_AMP_VAL_OFS(0x10, 3, 0, HDA_OUTPUT, 28),
2524 },
2525 {}
2526};
2527
34cbe3a6 2528static const struct snd_kcontrol_new cxt5066_mixer_olpc_dc[] = {
c4cfe66c
DD		 2529 {
2530 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2531 .name = "DC Mode Enable Switch",
2532 .info = snd_ctl_boolean_mono_info,
2533 .get = cxt5066_olpc_dc_get,
2534 .put = cxt5066_olpc_dc_put,
2535 },
2536 {
2537 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2538 .name = "DC Input Bias Enum",
2539 .info = cxt5066_olpc_dc_bias_enum_info,
2540 .get = cxt5066_olpc_dc_bias_enum_get,
2541 .put = cxt5066_olpc_dc_bias_enum_put,
2542 },
2543 {}
2544};
2545
34cbe3a6 2546static const struct snd_kcontrol_new cxt5066_mixers[] = {
0fb67e98
DD		 2547 {
2548 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2549 .name = "Master Playback Switch",
2550 .info = cxt_eapd_info,
2551 .get = cxt_eapd_get,
2552 .put = cxt5066_hp_master_sw_put,
2553 .private_value = 0x1d,
2554 },
2555
2556 {
2557 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
c4cfe66c 2558 .name = "Analog Mic Boost Capture Enum",
0fb67e98
DD		 2559 .info = cxt5066_mic_boost_mux_enum_info,
2560 .get = cxt5066_mic_boost_mux_enum_get,
2561 .put = cxt5066_mic_boost_mux_enum_put,
2562 },
2563
2564 HDA_BIND_VOL("Capture Volume", &cxt5066_bind_capture_vol_others),
2565 HDA_BIND_SW("Capture Switch", &cxt5066_bind_capture_sw_others),
2566 {}
2567};
2568
34cbe3a6 2569static const struct snd_kcontrol_new cxt5066_vostro_mixers[] = {
254bba6a
ER		 2570 {
2571 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28c4edb7 2572 .name = "Internal Mic Boost Capture Enum",
254bba6a
ER		 2573 .info = cxt5066_mic_boost_mux_enum_info,
2574 .get = cxt5066_mic_boost_mux_enum_get,
2575 .put = cxt5066_mic_boost_mux_enum_put,
2576 .private_value = 0x23 | 0x100,
2577 },
2578 {}
2579};
2580
34cbe3a6 2581static const struct hda_verb cxt5066_init_verbs[] = {
0fb67e98
DD		 2582 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port B */
2583 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port C */
2584 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port F */
2585 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port E */
2586
2587 /* Speakers */
2588 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2589 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2590
2591 /* HP, Amp */
2592 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2593 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2594
2595 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2596 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2597
2598 /* DAC1 */
2599 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2600
2601 /* Node 14 connections: 0x17 0x18 0x23 0x24 0x27 */
2602 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50},
2603 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2604 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2) | 0x50},
2605 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2606 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2607
2608 /* no digital microphone support yet */
2609 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2610
2611 /* Audio input selector */
2612 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3},
2613
2614 /* SPDIF route: PCM */
2615 {0x20, AC_VERB_SET_CONNECT_SEL, 0x0},
2616 {0x22, AC_VERB_SET_CONNECT_SEL, 0x0},
2617
2618 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2619 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2620
2621 /* EAPD */
2622 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
2623
2624 /* not handling these yet */
2625 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2626 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2627 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2628 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2629 {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2630 {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2631 {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2632 {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
2633 { } /* end */
2634};
2635
34cbe3a6 2636static const struct hda_verb cxt5066_init_verbs_olpc[] = {
0fb67e98
DD		 2637 /* Port A: headphones */
2638 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2639 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2640
2641 /* Port B: external microphone */
75f8991d 2642 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
0fb67e98
DD		 2643
2644 /* Port C: internal microphone */
75f8991d 2645 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
0fb67e98
DD		 2646
2647 /* Port D: unused */
2648 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2649
2650 /* Port E: unused, but has primary EAPD */
2651 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2652 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
2653
c4cfe66c 2654 /* Port F: external DC input through microphone port */
0fb67e98
DD		 2655 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2656
2657 /* Port G: internal speakers */
2658 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2659 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2660
2661 /* DAC1 */
2662 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2663
2664 /* DAC2: unused */
2665 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2666
2667 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50},
2668 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2669 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2670 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2671 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2672 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2673 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2674 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2675 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2676 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2677 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2678 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2679
2680 /* Disable digital microphone port */
2681 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2682
2683 /* Audio input selectors */
2684 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3},
2685 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2686
2687 /* Disable SPDIF */
2688 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2689 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2690
2691 /* enable unsolicited events for Port A and B */
2692 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
2693 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
2694 { } /* end */
2695};
2696
34cbe3a6 2697static const struct hda_verb cxt5066_init_verbs_vostro[] = {
95a618bd
ER		 2698 /* Port A: headphones */
2699 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2700 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2701
2702 /* Port B: external microphone */
2703 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2704
2705 /* Port C: unused */
2706 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2707
2708 /* Port D: unused */
2709 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2710
2711 /* Port E: unused, but has primary EAPD */
2712 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2713 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
2714
2715 /* Port F: unused */
2716 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2717
2718 /* Port G: internal speakers */
2719 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2720 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2721
2722 /* DAC1 */
2723 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2724
2725 /* DAC2: unused */
2726 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2727
2728 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2729 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2730 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2731 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2732 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2733 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2734 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2735 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2736 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2737 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2738 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2739 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2740
2741 /* Digital microphone port */
2742 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2743
2744 /* Audio input selectors */
2745 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3},
2746 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2747
2748 /* Disable SPDIF */
2749 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2750 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2751
2752 /* enable unsolicited events for Port A and B */
2753 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
2754 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
2755 { } /* end */
2756};
2757
34cbe3a6 2758static const struct hda_verb cxt5066_init_verbs_ideapad[] = {
cfd3d8dc
GA		 2759 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port B */
2760 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port C */
2761 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port F */
2762 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port E */
2763
2764 /* Speakers */
2765 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2766 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2767
2768 /* HP, Amp */
2769 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2770 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2771
2772 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2773 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2774
2775 /* DAC1 */
2776 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2777
2778 /* Node 14 connections: 0x17 0x18 0x23 0x24 0x27 */
2779 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50},
2780 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2781 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2) | 0x50},
2782 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2783 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2784 {0x14, AC_VERB_SET_CONNECT_SEL, 2}, /* default to internal mic */
2785
2786 /* Audio input selector */
2787 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x2},
2788 {0x17, AC_VERB_SET_CONNECT_SEL, 1}, /* route ext mic */
2789
2790 /* SPDIF route: PCM */
2791 {0x20, AC_VERB_SET_CONNECT_SEL, 0x0},
2792 {0x22, AC_VERB_SET_CONNECT_SEL, 0x0},
2793
2794 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2795 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2796
2797 /* internal microphone */
28c4edb7 2798 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* enable internal mic */
cfd3d8dc
GA		 2799
2800 /* EAPD */
2801 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
2802
2803 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
2804 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
2805 { } /* end */
2806};
2807
34cbe3a6 2808static const struct hda_verb cxt5066_init_verbs_thinkpad[] = {
7b2bfdbc
JT		 2809 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port F */
2810 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port E */
2811
2812 /* Port G: internal speakers */
2813 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2814 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2815
2816 /* Port A: HP, Amp */
2817 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2818 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2819
2820 /* Port B: Mic Dock */
2821 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2822
2823 /* Port C: Mic */
2824 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2825
2826 /* Port D: HP Dock, Amp */
2827 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
2828 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
2829
2830 /* DAC1 */
2831 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2832
2833 /* Node 14 connections: 0x17 0x18 0x23 0x24 0x27 */
2834 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50},
2835 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2836 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2) | 0x50},
2837 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2838 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2839 {0x14, AC_VERB_SET_CONNECT_SEL, 2}, /* default to internal mic */
2840
2841 /* Audio input selector */
2842 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x2},
2843 {0x17, AC_VERB_SET_CONNECT_SEL, 1}, /* route ext mic */
2844
2845 /* SPDIF route: PCM */
2846 {0x20, AC_VERB_SET_CONNECT_SEL, 0x0},
2847 {0x22, AC_VERB_SET_CONNECT_SEL, 0x0},
2848
2849 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2850 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2851
2852 /* internal microphone */
28c4edb7 2853 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* enable internal mic */
7b2bfdbc
JT		 2854
2855 /* EAPD */
2856 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
2857
2858 /* enable unsolicited events for Port A, B, C and D */
2859 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
2860 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
2861 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
2862 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
2863 { } /* end */
2864};
2865
34cbe3a6 2866static const struct hda_verb cxt5066_init_verbs_portd_lo[] = {
0fb67e98
DD		 2867 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2868 { } /* end */
2869};
2870
048e78a5 2871
34cbe3a6 2872static const struct hda_verb cxt5066_init_verbs_hp_laptop[] = {
048e78a5
DH		 2873 {0x14, AC_VERB_SET_CONNECT_SEL, 0x0},
2874 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
2875 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
2876 { } /* end */
2877};
2878
0fb67e98
DD		 2879/* initialize jack-sensing, too */
2880static int cxt5066_init(struct hda_codec *codec)
2881{
2882 snd_printdd("CXT5066: init\n");
2883 conexant_init(codec);
2884 if (codec->patch_ops.unsol_event) {
2885 cxt5066_hp_automute(codec);
02b6b5b6 2886 cxt5066_automic(codec);
0fb67e98 2887 }
c4cfe66c 2888 cxt5066_set_mic_boost(codec);
0fb67e98
DD		 2889 return 0;
2890}
2891
75f8991d
DD		 2892static int cxt5066_olpc_init(struct hda_codec *codec)
2893{
c4cfe66c 2894 struct conexant_spec *spec = codec->spec;
75f8991d
DD		 2895 snd_printdd("CXT5066: init\n");
2896 conexant_init(codec);
2897 cxt5066_hp_automute(codec);
c4cfe66c
DD		 2898 if (!spec->dc_enable) {
2899 cxt5066_set_mic_boost(codec);
2900 cxt5066_olpc_automic(codec);
2901 } else {
2902 cxt5066_enable_dc(codec);
2903 }
75f8991d
DD		 2904 return 0;
2905}
2906
0fb67e98 2907enum {
7b2bfdbc 2908 CXT5066_LAPTOP, /* Laptops w/ EAPD support */
0fb67e98
DD		 2909 CXT5066_DELL_LAPTOP, /* Dell Laptop */
2910 CXT5066_OLPC_XO_1_5, /* OLPC XO 1.5 */
1feba3b7 2911 CXT5066_DELL_VOSTRO, /* Dell Vostro 1015i */
cfd3d8dc 2912 CXT5066_IDEAPAD, /* Lenovo IdeaPad U150 */
7b2bfdbc 2913 CXT5066_THINKPAD, /* Lenovo ThinkPad T410s, others? */
a1d6906e 2914 CXT5066_ASUS, /* Asus K52JU, Lenovo G560 - Int mic at 0x1a and Ext mic at 0x1b */
048e78a5 2915 CXT5066_HP_LAPTOP, /* HP Laptop */
fea4a4f9 2916 CXT5066_AUTO, /* BIOS auto-parser */
0fb67e98
DD		 2917 CXT5066_MODELS
2918};
2919
ea734963 2920static const char * const cxt5066_models[CXT5066_MODELS] = {
7b2bfdbc 2921 [CXT5066_LAPTOP] = "laptop",
0fb67e98
DD		 2922 [CXT5066_DELL_LAPTOP] = "dell-laptop",
2923 [CXT5066_OLPC_XO_1_5] = "olpc-xo-1_5",
1feba3b7 2924 [CXT5066_DELL_VOSTRO] = "dell-vostro",
cfd3d8dc 2925 [CXT5066_IDEAPAD] = "ideapad",
7b2bfdbc 2926 [CXT5066_THINKPAD] = "thinkpad",
a1d6906e 2927 [CXT5066_ASUS] = "asus",
048e78a5 2928 [CXT5066_HP_LAPTOP] = "hp-laptop",
fea4a4f9 2929 [CXT5066_AUTO] = "auto",
0fb67e98
DD		 2930};
2931
34cbe3a6 2932static const struct snd_pci_quirk cxt5066_cfg_tbl[] = {
00cd0bb7 2933 SND_PCI_QUIRK_MASK(0x1025, 0xff00, 0x0400, "Acer", CXT5066_IDEAPAD),
1feba3b7 2934 SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTRO),
8a96b1e0 2935 SND_PCI_QUIRK(0x1028, 0x02f5, "Dell Vostro 320", CXT5066_IDEAPAD),
ca6cd851 2936 SND_PCI_QUIRK(0x1028, 0x0401, "Dell Vostro 1014", CXT5066_DELL_VOSTRO),
231f50bc 2937 SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD),
ebbd224c
DH		 2938 SND_PCI_QUIRK(0x1028, 0x050f, "Dell Inspiron", CXT5066_IDEAPAD),
2939 SND_PCI_QUIRK(0x1028, 0x0510, "Dell Vostro", CXT5066_IDEAPAD),
048e78a5 2940 SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP),
f6a2491c 2941 SND_PCI_QUIRK(0x1043, 0x13f3, "Asus A52J", CXT5066_ASUS),
a1d6906e 2942 SND_PCI_QUIRK(0x1043, 0x1643, "Asus K52JU", CXT5066_ASUS),
f6a2491c 2943 SND_PCI_QUIRK(0x1043, 0x1993, "Asus U50F", CXT5066_ASUS),
2ca9cac9 2944 SND_PCI_QUIRK(0x1179, 0xff1e, "Toshiba Satellite C650D", CXT5066_IDEAPAD),
c5366681 2945 SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5),
5637edb2
DH		 2946 SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
2947 CXT5066_LAPTOP),
2948 SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5),
4d155641 2949 SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400s", CXT5066_THINKPAD),
ef61d4e6 2950 SND_PCI_QUIRK(0x17aa, 0x21c5, "Thinkpad Edge 13", CXT5066_THINKPAD),
19593875 2951 SND_PCI_QUIRK(0x17aa, 0x21c6, "Thinkpad Edge 13", CXT5066_ASUS),
d2859fd4 2952 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo U350", CXT5066_ASUS),
a1d6906e 2953 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo G560", CXT5066_ASUS),
0fb67e98
DD		 2954 {}
2955};
2956
2957static int patch_cxt5066(struct hda_codec *codec)
2958{
2959 struct conexant_spec *spec;
2960 int board_config;
2961
fea4a4f9
TI		 2962 board_config = snd_hda_check_board_config(codec, CXT5066_MODELS,
2963 cxt5066_models, cxt5066_cfg_tbl);
fea4a4f9 2964 if (board_config < 0)
c82693db 2965 board_config = CXT5066_AUTO; /* model=auto as default */
fea4a4f9
TI		 2966 if (board_config == CXT5066_AUTO)
2967 return patch_conexant_auto(codec);
2968
0fb67e98
DD		 2969 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2970 if (!spec)
2971 return -ENOMEM;
2972 codec->spec = spec;
2973
2974 codec->patch_ops = conexant_patch_ops;
75f8991d 2975 codec->patch_ops.init = conexant_init;
0fb67e98
DD		 2976
2977 spec->dell_automute = 0;
2978 spec->multiout.max_channels = 2;
2979 spec->multiout.num_dacs = ARRAY_SIZE(cxt5066_dac_nids);
2980 spec->multiout.dac_nids = cxt5066_dac_nids;
f6a2491c
AR		 2981 conexant_check_dig_outs(codec, cxt5066_digout_pin_nids,
2982 ARRAY_SIZE(cxt5066_digout_pin_nids));
0fb67e98
DD		 2983 spec->num_adc_nids = 1;
2984 spec->adc_nids = cxt5066_adc_nids;
2985 spec->capsrc_nids = cxt5066_capsrc_nids;
2986 spec->input_mux = &cxt5066_capture_source;
2987
2988 spec->port_d_mode = PIN_HP;
2989
2990 spec->num_init_verbs = 1;
2991 spec->init_verbs[0] = cxt5066_init_verbs;
2992 spec->num_channel_mode = ARRAY_SIZE(cxt5066_modes);
2993 spec->channel_mode = cxt5066_modes;
2994 spec->cur_adc = 0;
2995 spec->cur_adc_idx = 0;
2996
3507e2a8
TI		 2997 set_beep_amp(spec, 0x13, 0, HDA_OUTPUT);
2998
0fb67e98
DD		 2999 switch (board_config) {
3000 default:
3001 case CXT5066_LAPTOP:
3002 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
3003 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
3004 break;
3005 case CXT5066_DELL_LAPTOP:
3006 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
3007 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
3008
3009 spec->port_d_mode = PIN_OUT;
3010 spec->init_verbs[spec->num_init_verbs] = cxt5066_init_verbs_portd_lo;
3011 spec->num_init_verbs++;
3012 spec->dell_automute = 1;
3013 break;
a1d6906e 3014 case CXT5066_ASUS:
048e78a5
DH		 3015 case CXT5066_HP_LAPTOP:
3016 codec->patch_ops.init = cxt5066_init;
02b6b5b6 3017 codec->patch_ops.unsol_event = cxt5066_unsol_event;
048e78a5
DH		 3018 spec->init_verbs[spec->num_init_verbs] =
3019 cxt5066_init_verbs_hp_laptop;
3020 spec->num_init_verbs++;
a1d6906e
DH		 3021 spec->hp_laptop = board_config == CXT5066_HP_LAPTOP;
3022 spec->asus = board_config == CXT5066_ASUS;
048e78a5
DH		 3023 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
3024 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
3025 /* no S/PDIF out */
f6a2491c
AR		 3026 if (board_config == CXT5066_HP_LAPTOP)
3027 spec->multiout.dig_out_nid = 0;
048e78a5
DH		 3028 /* input source automatically selected */
3029 spec->input_mux = NULL;
3030 spec->port_d_mode = 0;
3031 spec->mic_boost = 3; /* default 30dB gain */
3032 break;
3033
0fb67e98 3034 case CXT5066_OLPC_XO_1_5:
75f8991d
DD		 3035 codec->patch_ops.init = cxt5066_olpc_init;
3036 codec->patch_ops.unsol_event = cxt5066_olpc_unsol_event;
0fb67e98
DD		 3037 spec->init_verbs[0] = cxt5066_init_verbs_olpc;
3038 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master_olpc;
c4cfe66c 3039 spec->mixers[spec->num_mixers++] = cxt5066_mixer_olpc_dc;
0fb67e98
DD		 3040 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
3041 spec->port_d_mode = 0;
c4cfe66c 3042 spec->mic_boost = 3; /* default 30dB gain */
0fb67e98
DD		 3043
3044 /* no S/PDIF out */
3045 spec->multiout.dig_out_nid = 0;
3046
95a618bd
ER		 3047 /* input source automatically selected */
3048 spec->input_mux = NULL;
75f8991d
DD		 3049
3050 /* our capture hooks which allow us to turn on the microphone LED
3051 * at the right time */
3052 spec->capture_prepare = cxt5066_olpc_capture_prepare;
3053 spec->capture_cleanup = cxt5066_olpc_capture_cleanup;
95a618bd 3054 break;
1feba3b7 3055 case CXT5066_DELL_VOSTRO:
75f8991d 3056 codec->patch_ops.init = cxt5066_init;
02b6b5b6 3057 codec->patch_ops.unsol_event = cxt5066_unsol_event;
95a618bd
ER		 3058 spec->init_verbs[0] = cxt5066_init_verbs_vostro;
3059 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master_olpc;
3060 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
254bba6a 3061 spec->mixers[spec->num_mixers++] = cxt5066_vostro_mixers;
95a618bd 3062 spec->port_d_mode = 0;
254bba6a 3063 spec->dell_vostro = 1;
c4cfe66c 3064 spec->mic_boost = 3; /* default 30dB gain */
95a618bd
ER		 3065
3066 /* no S/PDIF out */
3067 spec->multiout.dig_out_nid = 0;
3068
cfd3d8dc
GA		 3069 /* input source automatically selected */
3070 spec->input_mux = NULL;
3071 break;
3072 case CXT5066_IDEAPAD:
3073 codec->patch_ops.init = cxt5066_init;
02b6b5b6 3074 codec->patch_ops.unsol_event = cxt5066_unsol_event;
cfd3d8dc
GA		 3075 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
3076 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
3077 spec->init_verbs[0] = cxt5066_init_verbs_ideapad;
3078 spec->port_d_mode = 0;
3079 spec->ideapad = 1;
3080 spec->mic_boost = 2; /* default 20dB gain */
3081
3082 /* no S/PDIF out */
3083 spec->multiout.dig_out_nid = 0;
3084
7b2bfdbc
JT		 3085 /* input source automatically selected */
3086 spec->input_mux = NULL;
3087 break;
3088 case CXT5066_THINKPAD:
3089 codec->patch_ops.init = cxt5066_init;
02b6b5b6 3090 codec->patch_ops.unsol_event = cxt5066_unsol_event;
7b2bfdbc
JT		 3091 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
3092 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
3093 spec->init_verbs[0] = cxt5066_init_verbs_thinkpad;
3094 spec->thinkpad = 1;
3095 spec->port_d_mode = PIN_OUT;
3096 spec->mic_boost = 2; /* default 20dB gain */
3097
3098 /* no S/PDIF out */
3099 spec->multiout.dig_out_nid = 0;
3100
0fb67e98
DD		 3101 /* input source automatically selected */
3102 spec->input_mux = NULL;
3103 break;
3104 }
3105
3507e2a8 3106 if (spec->beep_amp)
a86b1a2c 3107 snd_hda_attach_beep_device(codec, get_amp_nid_(spec->beep_amp));
3507e2a8 3108
0fb67e98
DD		 3109 return 0;
3110}
461e2c78 3111
bf92d1d5
TI		 3112#endif /* ENABLE_CXT_STATIC_QUIRKS */
3113
3114
f2e5731d
TI		 3115/*
3116 * Automatic parser for CX20641 & co
3117 */
3118
f2e5731d
TI		 3119#ifdef CONFIG_SND_HDA_INPUT_BEEP
3120static void cx_auto_parse_beep(struct hda_codec *codec)
6764bcef
TI		 3121{
3122 struct conexant_spec *spec = codec->spec;
f2e5731d 3123 hda_nid_t nid, end_nid;
f2e5731d 3124
f2e5731d
TI		 3125 end_nid = codec->start_nid + codec->num_nodes;
3126 for (nid = codec->start_nid; nid < end_nid; nid++)
3127 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP) {
3128 set_beep_amp(spec, nid, 0, HDA_OUTPUT);
f2e5731d
TI		 3129 break;
3130 }
f2e5731d 3131}
f2e5731d
TI		 3132#else
3133#define cx_auto_parse_beep(codec)
3134#endif
f2e5731d 3135
254f2968 3136/* parse EAPDs */
19110595 3137static void cx_auto_parse_eapd(struct hda_codec *codec)
f2e5731d 3138{
19110595 3139 struct conexant_spec *spec = codec->spec;
f2e5731d 3140 hda_nid_t nid, end_nid;
f2e5731d
TI		 3141
3142 end_nid = codec->start_nid + codec->num_nodes;
3143 for (nid = codec->start_nid; nid < end_nid; nid++) {
19110595 3144 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
468c5458 3145 continue;
19110595 3146 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD))
f2e5731d 3147 continue;
19110595
TI		 3148 spec->eapds[spec->num_eapds++] = nid;
3149 if (spec->num_eapds >= ARRAY_SIZE(spec->eapds))
03697e2a 3150 break;
03697e2a
TI		 3151 }
3152
254f2968
TI		 3153 /* NOTE: below is a wild guess; if we have more than two EAPDs,
3154 * it's a new chip, where EAPDs are supposed to be associated to
3155 * pins, and we can control EAPD per pin.
3156 * OTOH, if only one or two EAPDs are found, it's an old chip,
3157 * thus it might control over all pins.
3158 */
aed523f1 3159 if (spec->num_eapds > 2)
ff359b14 3160 spec->dynamic_eapd = 1;
f2e5731d
TI		 3161}
3162
da339866 3163static void cx_auto_turn_eapd(struct hda_codec *codec, int num_pins,
da339866 3164 hda_nid_t *pins, bool on)
03697e2a
TI		 3165{
3166 int i;
03697e2a 3167 for (i = 0; i < num_pins; i++) {
f2e5731d
TI		 3168 if (snd_hda_query_pin_caps(codec, pins[i]) & AC_PINCAP_EAPD)
3169 snd_hda_codec_write(codec, pins[i], 0,
da339866
TI		 3170 AC_VERB_SET_EAPD_BTLENABLE,
3171 on ? 0x02 : 0);
e2df82ff 3172 }
03697e2a
TI		 3173}
3174
527c73ba
TI		 3175/* turn on/off EAPD according to Master switch */
3176static void cx_auto_vmaster_hook(void *private_data, int enabled)
f2e5731d 3177{
527c73ba 3178 struct hda_codec *codec = private_data;
f2e5731d 3179 struct conexant_spec *spec = codec->spec;
f2e5731d 3180
527c73ba 3181 cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, enabled);
03697e2a
TI		 3182}
3183
f2e5731d 3184static int cx_auto_build_controls(struct hda_codec *codec)
03697e2a 3185{
f2e5731d 3186 int err;
03697e2a 3187
aed523f1 3188 err = snd_hda_gen_build_controls(codec);
f2e5731d
TI		 3189 if (err < 0)
3190 return err;
03697e2a 3191
aed523f1 3192 err = add_beep_ctls(codec);
31ef2257
TI		 3193 if (err < 0)
3194 return err;
03697e2a 3195
03697e2a
TI		 3196 return 0;
3197}
3198
ff359b14
TI		 3199static int cx_auto_init(struct hda_codec *codec)
3200{
3201 struct conexant_spec *spec = codec->spec;
3202 snd_hda_gen_init(codec);
3203 if (!spec->dynamic_eapd)
3204 cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, true);
e4c3bce2
DH		 3205
3206 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
3207
ff359b14
TI		 3208 return 0;
3209}
3210
34cbe3a6 3211static const struct hda_codec_ops cx_auto_patch_ops = {
f2e5731d 3212 .build_controls = cx_auto_build_controls,
aed523f1 3213 .build_pcms = snd_hda_gen_build_pcms,
ff359b14 3214 .init = cx_auto_init,
7504b6cd 3215 .free = snd_hda_gen_free,
29adc4b9 3216 .unsol_event = snd_hda_jack_unsol_event,
164a7ada
TI		 3217#ifdef CONFIG_PM
3218 .check_power_status = snd_hda_gen_check_power_status,
3219#endif
f2e5731d 3220};
f2e5731d 3221
e92d4b08
TI		 3222/*
3223 * pin fix-up
3224 */
18dcd304
DH		 3225enum {
3226 CXT_PINCFG_LENOVO_X200,
d3980110 3227 CXT_PINCFG_LENOVO_TP410,
239fb862
HC		 3228 CXT_PINCFG_LEMOTE_A1004,
3229 CXT_PINCFG_LEMOTE_A1205,
18dcd304 3230 CXT_FIXUP_STEREO_DMIC,
239fb862 3231 CXT_FIXUP_INC_MIC_BOOST,
e4c3bce2
DH		 3232 CXT_FIXUP_HEADPHONE_MIC_PIN,
3233 CXT_FIXUP_HEADPHONE_MIC,
03697e2a
TI		 3234};
3235
23d30f28
TI		 3236static void cxt_fixup_stereo_dmic(struct hda_codec *codec,
3237 const struct hda_fixup *fix, int action)
6764bcef 3238{
6764bcef 3239 struct conexant_spec *spec = codec->spec;
aed523f1 3240 spec->gen.inv_dmic_split = 1;
6764bcef
TI		 3241}
3242
239fb862
HC		 3243static void cxt5066_increase_mic_boost(struct hda_codec *codec,
3244 const struct hda_fixup *fix, int action)
6764bcef 3245{
239fb862
HC		 3246 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3247 return;
6764bcef 3248
239fb862
HC		 3249 snd_hda_override_amp_caps(codec, 0x17, HDA_OUTPUT,
3250 (0x3 << AC_AMPCAP_OFFSET_SHIFT) |
3251 (0x4 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3252 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3253 (0 << AC_AMPCAP_MUTE_SHIFT));
3254}
3255
e4c3bce2
DH		 3256static void cxt_update_headset_mode(struct hda_codec *codec)
3257{
3258 /* The verbs used in this function were tested on a Conexant CX20751/2 codec. */
3259 int i;
3260 bool mic_mode = false;
3261 struct conexant_spec *spec = codec->spec;
3262 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
3263
3264 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
3265
3266 for (i = 0; i < cfg->num_inputs; i++)
3267 if (cfg->inputs[i].pin == mux_pin) {
3268 mic_mode = !!cfg->inputs[i].is_headphone_mic;
3269 break;
3270 }
3271
3272 if (mic_mode) {
3273 snd_hda_codec_write_cache(codec, 0x1c, 0, 0x410, 0x7c); /* enable merged mode for analog int-mic */
3274 spec->gen.hp_jack_present = false;
3275 } else {
3276 snd_hda_codec_write_cache(codec, 0x1c, 0, 0x410, 0x54); /* disable merged mode for analog int-mic */
3277 spec->gen.hp_jack_present = snd_hda_jack_detect(codec, spec->gen.autocfg.hp_pins[0]);
3278 }
3279
3280 snd_hda_gen_update_outputs(codec);
3281}
3282
3283static void cxt_update_headset_mode_hook(struct hda_codec *codec,
3284 struct snd_ctl_elem_value *ucontrol)
3285{
3286 cxt_update_headset_mode(codec);
3287}
3288
3289static void cxt_fixup_headphone_mic(struct hda_codec *codec,
3290 const struct hda_fixup *fix, int action)
3291{
3292 struct conexant_spec *spec = codec->spec;
3293
3294 switch (action) {
3295 case HDA_FIXUP_ACT_PRE_PROBE:
3296 spec->parse_flags |= HDA_PINCFG_HEADPHONE_MIC;
3297 break;
3298 case HDA_FIXUP_ACT_PROBE:
3299 spec->gen.cap_sync_hook = cxt_update_headset_mode_hook;
3300 spec->gen.automute_hook = cxt_update_headset_mode;
3301 break;
3302 case HDA_FIXUP_ACT_INIT:
3303 cxt_update_headset_mode(codec);
3304 break;
3305 }
3306}
3307
3308
d70f3632 3309/* ThinkPad X200 & co with cxt5051 */
23d30f28 3310static const struct hda_pintbl cxt_pincfg_lenovo_x200[] = {
e92d4b08
TI		 3311 { 0x16, 0x042140ff }, /* HP (seq# overridden) */
3312 { 0x17, 0x21a11000 }, /* dock-mic */
3313 { 0x19, 0x2121103f }, /* dock-HP */
3e93f5ef 3314 { 0x1c, 0x21440100 }, /* dock SPDIF out */
e92d4b08
TI		 3315 {}
3316};
3317
d70f3632 3318/* ThinkPad 410/420/510/520, X201 & co with cxt5066 */
23d30f28 3319static const struct hda_pintbl cxt_pincfg_lenovo_tp410[] = {
d70f3632
TI		 3320 { 0x19, 0x042110ff }, /* HP (seq# overridden) */
3321 { 0x1a, 0x21a190f0 }, /* dock-mic */
3322 { 0x1c, 0x212140ff }, /* dock-HP */
3323 {}
3324};
3325
239fb862
HC		 3326/* Lemote A1004/A1205 with cxt5066 */
3327static const struct hda_pintbl cxt_pincfg_lemote[] = {
3328 { 0x1a, 0x90a10020 }, /* Internal mic */
3329 { 0x1b, 0x03a11020 }, /* External mic */
3330 { 0x1d, 0x400101f0 }, /* Not used */
3331 { 0x1e, 0x40a701f0 }, /* Not used */
3332 { 0x20, 0x404501f0 }, /* Not used */
3333 { 0x22, 0x404401f0 }, /* Not used */
3334 { 0x23, 0x40a701f0 }, /* Not used */
3335 {}
3336};
3337
23d30f28
TI		 3338static const struct hda_fixup cxt_fixups[] = {
3339 [CXT_PINCFG_LENOVO_X200] = {
3340 .type = HDA_FIXUP_PINS,
3341 .v.pins = cxt_pincfg_lenovo_x200,
3342 },
3343 [CXT_PINCFG_LENOVO_TP410] = {
3344 .type = HDA_FIXUP_PINS,
3345 .v.pins = cxt_pincfg_lenovo_tp410,
3346 },
239fb862
HC		 3347 [CXT_PINCFG_LEMOTE_A1004] = {
3348 .type = HDA_FIXUP_PINS,
3349 .chained = true,
3350 .chain_id = CXT_FIXUP_INC_MIC_BOOST,
3351 .v.pins = cxt_pincfg_lemote,
3352 },
3353 [CXT_PINCFG_LEMOTE_A1205] = {
3354 .type = HDA_FIXUP_PINS,
3355 .v.pins = cxt_pincfg_lemote,
3356 },
23d30f28
TI		 3357 [CXT_FIXUP_STEREO_DMIC] = {
3358 .type = HDA_FIXUP_FUNC,
3359 .v.func = cxt_fixup_stereo_dmic,
3360 },
239fb862
HC		 3361 [CXT_FIXUP_INC_MIC_BOOST] = {
3362 .type = HDA_FIXUP_FUNC,
3363 .v.func = cxt5066_increase_mic_boost,
3364 },
e4c3bce2
DH		 3365 [CXT_FIXUP_HEADPHONE_MIC_PIN] = {
3366 .type = HDA_FIXUP_PINS,
3367 .chained = true,
3368 .chain_id = CXT_FIXUP_HEADPHONE_MIC,
3369 .v.pins = (const struct hda_pintbl[]) {
3370 { 0x18, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
3371 { }
3372 }
3373 },
3374 [CXT_FIXUP_HEADPHONE_MIC] = {
3375 .type = HDA_FIXUP_FUNC,
3376 .v.func = cxt_fixup_headphone_mic,
3377 },
e92d4b08
TI		 3378};
3379
d70f3632 3380static const struct snd_pci_quirk cxt5051_fixups[] = {
e92d4b08
TI		 3381 SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo X200", CXT_PINCFG_LENOVO_X200),
3382 {}
3383};
3384
d70f3632 3385static const struct snd_pci_quirk cxt5066_fixups[] = {
63a077e2 3386 SND_PCI_QUIRK(0x1025, 0x0543, "Acer Aspire One 522", CXT_FIXUP_STEREO_DMIC),
e4c3bce2 3387 SND_PCI_QUIRK(0x1043, 0x138d, "Asus", CXT_FIXUP_HEADPHONE_MIC_PIN),
d70f3632
TI		 3388 SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400", CXT_PINCFG_LENOVO_TP410),
3389 SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo T410", CXT_PINCFG_LENOVO_TP410),
3390 SND_PCI_QUIRK(0x17aa, 0x215f, "Lenovo T510", CXT_PINCFG_LENOVO_TP410),
3391 SND_PCI_QUIRK(0x17aa, 0x21ce, "Lenovo T420", CXT_PINCFG_LENOVO_TP410),
3392 SND_PCI_QUIRK(0x17aa, 0x21cf, "Lenovo T520", CXT_PINCFG_LENOVO_TP410),
a555bb8c 3393 SND_PCI_QUIRK(0x17aa, 0x21da, "Lenovo X220", CXT_PINCFG_LENOVO_TP410),
88d57606 3394 SND_PCI_QUIRK(0x17aa, 0x21db, "Lenovo X220-tablet", CXT_PINCFG_LENOVO_TP410),
18dcd304 3395 SND_PCI_QUIRK(0x17aa, 0x3975, "Lenovo U300s", CXT_FIXUP_STEREO_DMIC),
e4db0952 3396 SND_PCI_QUIRK(0x17aa, 0x3977, "Lenovo IdeaPad U310", CXT_FIXUP_STEREO_DMIC),
b3c5dce8 3397 SND_PCI_QUIRK(0x17aa, 0x397b, "Lenovo S205", CXT_FIXUP_STEREO_DMIC),
239fb862
HC		 3398 SND_PCI_QUIRK(0x1c06, 0x2011, "Lemote A1004", CXT_PINCFG_LEMOTE_A1004),
3399 SND_PCI_QUIRK(0x1c06, 0x2012, "Lemote A1205", CXT_PINCFG_LEMOTE_A1205),
e92d4b08
TI		 3400 {}
3401};
3402
3868137e
TI		 3403/* add "fake" mute amp-caps to DACs on cx5051 so that mixer mute switches
3404 * can be created (bko#42825)
3405 */
3406static void add_cx5051_fake_mutes(struct hda_codec *codec)
3407{
3408 static hda_nid_t out_nids[] = {
3409 0x10, 0x11, 0
3410 };
3411 hda_nid_t *p;
3412
3413 for (p = out_nids; *p; p++)
3414 snd_hda_override_amp_caps(codec, *p, HDA_OUTPUT,
3415 AC_AMPCAP_MIN_MUTE |
3416 query_amp_caps(codec, *p, HDA_OUTPUT));
3417}
3418
f2e5731d
TI		 3419static int patch_conexant_auto(struct hda_codec *codec)
3420{
3421 struct conexant_spec *spec;
3422 int err;
3423
1f8458a2
TI		 3424 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3425 codec->chip_name);
3426
f2e5731d
TI		 3427 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3428 if (!spec)
3429 return -ENOMEM;
aed523f1 3430 snd_hda_gen_spec_init(&spec->gen);
f2e5731d 3431 codec->spec = spec;
e92d4b08 3432
aed523f1
TI		 3433 cx_auto_parse_beep(codec);
3434 cx_auto_parse_eapd(codec);
ff359b14
TI		 3435 spec->gen.own_eapd_ctl = 1;
3436 if (spec->dynamic_eapd)
aed523f1 3437 spec->gen.vmaster_mute.hook = cx_auto_vmaster_hook;
e92d4b08 3438
6b452142
TI		 3439 switch (codec->vendor_id) {
3440 case 0x14f15045:
4f32456e 3441 codec->single_adc_amp = 1;
6b452142 3442 break;
164a7ada
TI		 3443 case 0x14f15047:
3444 codec->pin_amp_workaround = 1;
3445 spec->gen.mixer_nid = 0x19;
3446 break;
3868137e
TI		 3447 case 0x14f15051:
3448 add_cx5051_fake_mutes(codec);
51969d62 3449 codec->pin_amp_workaround = 1;
23d30f28 3450 snd_hda_pick_fixup(codec, NULL, cxt5051_fixups, cxt_fixups);
3868137e 3451 break;
51969d62
MK		 3452 default:
3453 codec->pin_amp_workaround = 1;
23d30f28
TI		 3454 snd_hda_pick_fixup(codec, NULL, cxt5066_fixups, cxt_fixups);
3455 break;
6b452142
TI		 3456 }
3457
f29735cb
TI		 3458 /* Show mute-led control only on HP laptops
3459 * This is a sort of white-list: on HP laptops, EAPD corresponds
3460 * only to the mute-LED without actualy amp function. Meanwhile,
3461 * others may use EAPD really as an amp switch, so it might be
3462 * not good to expose it blindly.
527c73ba 3463 */
f29735cb
TI		 3464 switch (codec->subsystem_id >> 16) {
3465 case 0x103c:
aed523f1 3466 spec->gen.vmaster_mute_enum = 1;
f29735cb
TI		 3467 break;
3468 }
527c73ba 3469
aed523f1
TI		 3470 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3471
e4c3bce2
DH		 3472 err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL,
3473 spec->parse_flags);
22ce5f74 3474 if (err < 0)
aed523f1
TI		 3475 goto error;
3476
3477 err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
3478 if (err < 0)
3479 goto error;
3480
f2e5731d 3481 codec->patch_ops = cx_auto_patch_ops;
4f2864a4
TI		 3482
3483 /* Some laptops with Conexant chips show stalls in S3 resume,
3484 * which falls into the single-cmd mode.
3485 * Better to make reset, then.
3486 */
3487 if (!codec->bus->sync_write) {
3488 snd_printd("hda_codec: "
3489 "Enable sync_write for stable communication\n");
3490 codec->bus->sync_write = 1;
3491 codec->bus->allow_bus_reset = 1;
3492 }
3493
e4c3bce2
DH		 3494 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3495
f2e5731d 3496 return 0;
aed523f1
TI		 3497
3498 error:
3499 snd_hda_gen_free(codec);
3500 return err;
f2e5731d
TI		 3501}
3502
bf92d1d5
TI		 3503#ifndef ENABLE_CXT_STATIC_QUIRKS
3504#define patch_cxt5045 patch_conexant_auto
3505#define patch_cxt5047 patch_conexant_auto
3506#define patch_cxt5051 patch_conexant_auto
3507#define patch_cxt5066 patch_conexant_auto
3508#endif
3509
461e2c78
TI		 3510/*
3511 */
3512
34cbe3a6 3513static const struct hda_codec_preset snd_hda_preset_conexant[] = {
82f30040
TD		 3514 { .id = 0x14f15045, .name = "CX20549 (Venice)",
3515 .patch = patch_cxt5045 },
3516 { .id = 0x14f15047, .name = "CX20551 (Waikiki)",
3517 .patch = patch_cxt5047 },
461e2c78
TI		 3518 { .id = 0x14f15051, .name = "CX20561 (Hermosa)",
3519 .patch = patch_cxt5051 },
0fb67e98
DD		 3520 { .id = 0x14f15066, .name = "CX20582 (Pebble)",
3521 .patch = patch_cxt5066 },
95a618bd
ER		 3522 { .id = 0x14f15067, .name = "CX20583 (Pebble HSF)",
3523 .patch = patch_cxt5066 },
850eab9d
TI		 3524 { .id = 0x14f15068, .name = "CX20584",
3525 .patch = patch_cxt5066 },
7b2bfdbc
JT		 3526 { .id = 0x14f15069, .name = "CX20585",
3527 .patch = patch_cxt5066 },
f0ca89b0
DH		 3528 { .id = 0x14f1506c, .name = "CX20588",
3529 .patch = patch_cxt5066 },
6da8b516
DH		 3530 { .id = 0x14f1506e, .name = "CX20590",
3531 .patch = patch_cxt5066 },
f2e5731d
TI		 3532 { .id = 0x14f15097, .name = "CX20631",
3533 .patch = patch_conexant_auto },
3534 { .id = 0x14f15098, .name = "CX20632",
3535 .patch = patch_conexant_auto },
3536 { .id = 0x14f150a1, .name = "CX20641",
3537 .patch = patch_conexant_auto },
3538 { .id = 0x14f150a2, .name = "CX20642",
3539 .patch = patch_conexant_auto },
3540 { .id = 0x14f150ab, .name = "CX20651",
3541 .patch = patch_conexant_auto },
3542 { .id = 0x14f150ac, .name = "CX20652",
3543 .patch = patch_conexant_auto },
3544 { .id = 0x14f150b8, .name = "CX20664",
3545 .patch = patch_conexant_auto },
3546 { .id = 0x14f150b9, .name = "CX20665",
3547 .patch = patch_conexant_auto },
2d825fd8
TI		 3548 { .id = 0x14f1510f, .name = "CX20751/2",
3549 .patch = patch_conexant_auto },
3550 { .id = 0x14f15110, .name = "CX20751/2",
3551 .patch = patch_conexant_auto },
3552 { .id = 0x14f15111, .name = "CX20753/4",
3553 .patch = patch_conexant_auto },
42c364ac
TI		 3554 { .id = 0x14f15113, .name = "CX20755",
3555 .patch = patch_conexant_auto },
3556 { .id = 0x14f15114, .name = "CX20756",
3557 .patch = patch_conexant_auto },
3558 { .id = 0x14f15115, .name = "CX20757",
3559 .patch = patch_conexant_auto },
c9b443d4
TD		 3560 {} /* terminator */
3561};
1289e9e8
TI		 3562
3563MODULE_ALIAS("snd-hda-codec-id:14f15045");
3564MODULE_ALIAS("snd-hda-codec-id:14f15047");
3565MODULE_ALIAS("snd-hda-codec-id:14f15051");
0fb67e98 3566MODULE_ALIAS("snd-hda-codec-id:14f15066");
95a618bd 3567MODULE_ALIAS("snd-hda-codec-id:14f15067");
850eab9d 3568MODULE_ALIAS("snd-hda-codec-id:14f15068");
7b2bfdbc 3569MODULE_ALIAS("snd-hda-codec-id:14f15069");
f0ca89b0 3570MODULE_ALIAS("snd-hda-codec-id:14f1506c");
6da8b516 3571MODULE_ALIAS("snd-hda-codec-id:14f1506e");
f2e5731d
TI		 3572MODULE_ALIAS("snd-hda-codec-id:14f15097");
3573MODULE_ALIAS("snd-hda-codec-id:14f15098");
3574MODULE_ALIAS("snd-hda-codec-id:14f150a1");
3575MODULE_ALIAS("snd-hda-codec-id:14f150a2");
3576MODULE_ALIAS("snd-hda-codec-id:14f150ab");
3577MODULE_ALIAS("snd-hda-codec-id:14f150ac");
3578MODULE_ALIAS("snd-hda-codec-id:14f150b8");
3579MODULE_ALIAS("snd-hda-codec-id:14f150b9");
2d825fd8
TI		 3580MODULE_ALIAS("snd-hda-codec-id:14f1510f");
3581MODULE_ALIAS("snd-hda-codec-id:14f15110");
3582MODULE_ALIAS("snd-hda-codec-id:14f15111");
42c364ac
TI		 3583MODULE_ALIAS("snd-hda-codec-id:14f15113");
3584MODULE_ALIAS("snd-hda-codec-id:14f15114");
3585MODULE_ALIAS("snd-hda-codec-id:14f15115");
1289e9e8
TI		 3586
3587MODULE_LICENSE("GPL");
3588MODULE_DESCRIPTION("Conexant HD-audio codec");
3589
3590static struct hda_codec_preset_list conexant_list = {
3591 .preset = snd_hda_preset_conexant,
3592 .owner = THIS_MODULE,
3593};
3594
3595static int __init patch_conexant_init(void)
3596{
3597 return snd_hda_add_codec_preset(&conexant_list);
3598}
3599
3600static void __exit patch_conexant_exit(void)
3601{
3602 snd_hda_delete_codec_preset(&conexant_list);
3603}
3604
3605module_init(patch_conexant_init)
3606module_exit(patch_conexant_exit)
Linux kernel - Deliverables
This page took 0.652977 seconds and 5 git commands to generate.