2 * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984,
5 * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/pci.h>
25 #include <linux/module.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include "hda_local.h"
30 #include "hda_auto_parser.h"
33 #include "hda_generic.h"
35 #define ENABLE_AD_STATIC_QUIRKS
38 struct hda_gen_spec gen;
42 unsigned int cur_smux;
45 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
47 #ifdef ENABLE_AD_STATIC_QUIRKS
48 const struct snd_kcontrol_new *mixers[6];
50 const struct hda_verb *init_verbs[6]; /* initialization verbs
51 * don't forget NULL termination!
53 unsigned int num_init_verbs;
56 struct hda_multi_out multiout; /* playback set-up
57 * max_channels, dacs must be set
58 * dig_out_nid and hp_nid are optional
60 unsigned int cur_eapd;
61 unsigned int need_dac_fix;
64 unsigned int num_adc_nids;
65 const hda_nid_t *adc_nids;
66 hda_nid_t dig_in_nid; /* digital-in NID; optional */
69 const struct hda_input_mux *input_mux;
70 const hda_nid_t *capsrc_nids;
71 unsigned int cur_mux[3];
74 const struct hda_channel_mode *channel_mode;
78 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
80 unsigned int spdif_route;
82 unsigned int jack_present: 1;
83 unsigned int inv_jack_detect: 1;/* inverted jack-detection */
84 unsigned int analog_beep: 1; /* analog beep input present */
85 unsigned int avoid_init_slave_vol:1;
88 struct hda_loopback_check loopback;
90 /* for virtual master */
91 hda_nid_t vmaster_nid;
92 const char * const *slave_vols;
93 const char * const *slave_sws;
94 #endif /* ENABLE_AD_STATIC_QUIRKS */
97 #ifdef ENABLE_AD_STATIC_QUIRKS
99 * input MUX handling (common part)
101 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
103 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
104 struct ad198x_spec *spec = codec->spec;
106 return snd_hda_input_mux_info(spec->input_mux, uinfo);
109 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
111 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
112 struct ad198x_spec *spec = codec->spec;
113 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
115 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
119 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
121 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
122 struct ad198x_spec *spec = codec->spec;
123 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
125 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
126 spec->capsrc_nids[adc_idx],
127 &spec->cur_mux[adc_idx]);
131 * initialization (common callbacks)
133 static int ad198x_init(struct hda_codec *codec)
135 struct ad198x_spec *spec = codec->spec;
138 for (i = 0; i < spec->num_init_verbs; i++)
139 snd_hda_sequence_write(codec, spec->init_verbs[i]);
143 static const char * const ad_slave_pfxs[] = {
144 "Front", "Surround", "Center", "LFE", "Side",
145 "Headphone", "Mono", "Speaker", "IEC958",
149 static const char * const ad1988_6stack_fp_slave_pfxs[] = {
150 "Front", "Surround", "Center", "LFE", "Side", "IEC958",
153 #endif /* ENABLE_AD_STATIC_QUIRKS */
155 #ifdef CONFIG_SND_HDA_INPUT_BEEP
156 /* additional beep mixers; the actual parameters are overwritten at build */
157 static const struct snd_kcontrol_new ad_beep_mixer[] = {
158 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),
159 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT),
163 static const struct snd_kcontrol_new ad_beep2_mixer[] = {
164 HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0, 0, HDA_OUTPUT),
165 HDA_CODEC_MUTE_BEEP("Digital Beep Playback Switch", 0, 0, HDA_OUTPUT),
169 #define set_beep_amp(spec, nid, idx, dir) \
170 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */
172 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
175 #ifdef CONFIG_SND_HDA_INPUT_BEEP
176 static int create_beep_ctls(struct hda_codec *codec)
178 struct ad198x_spec *spec = codec->spec;
179 const struct snd_kcontrol_new *knew;
184 knew = spec->analog_beep ? ad_beep2_mixer : ad_beep_mixer;
185 for ( ; knew->name; knew++) {
187 struct snd_kcontrol *kctl;
188 kctl = snd_ctl_new1(knew, codec);
191 kctl->private_value = spec->beep_amp;
192 err = snd_hda_ctl_add(codec, 0, kctl);
199 #define create_beep_ctls(codec) 0
202 #ifdef ENABLE_AD_STATIC_QUIRKS
203 static int ad198x_build_controls(struct hda_codec *codec)
205 struct ad198x_spec *spec = codec->spec;
206 struct snd_kcontrol *kctl;
210 for (i = 0; i < spec->num_mixers; i++) {
211 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
215 if (spec->multiout.dig_out_nid) {
216 err = snd_hda_create_spdif_out_ctls(codec,
217 spec->multiout.dig_out_nid,
218 spec->multiout.dig_out_nid);
221 err = snd_hda_create_spdif_share_sw(codec,
225 spec->multiout.share_spdif = 1;
227 if (spec->dig_in_nid) {
228 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
233 /* create beep controls if needed */
234 err = create_beep_ctls(codec);
238 /* if we have no master control, let's create it */
239 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
240 unsigned int vmaster_tlv[4];
241 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
242 HDA_OUTPUT, vmaster_tlv);
243 err = __snd_hda_add_vmaster(codec, "Master Playback Volume",
246 spec->slave_vols : ad_slave_pfxs),
248 !spec->avoid_init_slave_vol, NULL);
252 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
253 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
256 spec->slave_sws : ad_slave_pfxs),
262 /* assign Capture Source enums to NID */
263 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
265 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
266 for (i = 0; kctl && i < kctl->count; i++) {
267 err = snd_hda_add_nid(codec, kctl, i, spec->capsrc_nids[i]);
272 /* assign IEC958 enums to NID */
273 kctl = snd_hda_find_mixer_ctl(codec,
274 SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source");
276 err = snd_hda_add_nid(codec, kctl, 0,
277 spec->multiout.dig_out_nid);
286 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
288 struct ad198x_spec *spec = codec->spec;
289 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
294 * Analog playback callbacks
296 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
297 struct hda_codec *codec,
298 struct snd_pcm_substream *substream)
300 struct ad198x_spec *spec = codec->spec;
301 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
305 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
306 struct hda_codec *codec,
307 unsigned int stream_tag,
309 struct snd_pcm_substream *substream)
311 struct ad198x_spec *spec = codec->spec;
312 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
316 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
317 struct hda_codec *codec,
318 struct snd_pcm_substream *substream)
320 struct ad198x_spec *spec = codec->spec;
321 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
327 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
328 struct hda_codec *codec,
329 struct snd_pcm_substream *substream)
331 struct ad198x_spec *spec = codec->spec;
332 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
335 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
336 struct hda_codec *codec,
337 struct snd_pcm_substream *substream)
339 struct ad198x_spec *spec = codec->spec;
340 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
343 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
344 struct hda_codec *codec,
345 unsigned int stream_tag,
347 struct snd_pcm_substream *substream)
349 struct ad198x_spec *spec = codec->spec;
350 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
354 static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
355 struct hda_codec *codec,
356 struct snd_pcm_substream *substream)
358 struct ad198x_spec *spec = codec->spec;
359 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
365 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
366 struct hda_codec *codec,
367 unsigned int stream_tag,
369 struct snd_pcm_substream *substream)
371 struct ad198x_spec *spec = codec->spec;
372 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
373 stream_tag, 0, format);
377 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
378 struct hda_codec *codec,
379 struct snd_pcm_substream *substream)
381 struct ad198x_spec *spec = codec->spec;
382 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
388 static const struct hda_pcm_stream ad198x_pcm_analog_playback = {
391 .channels_max = 6, /* changed later */
392 .nid = 0, /* fill later */
394 .open = ad198x_playback_pcm_open,
395 .prepare = ad198x_playback_pcm_prepare,
396 .cleanup = ad198x_playback_pcm_cleanup,
400 static const struct hda_pcm_stream ad198x_pcm_analog_capture = {
404 .nid = 0, /* fill later */
406 .prepare = ad198x_capture_pcm_prepare,
407 .cleanup = ad198x_capture_pcm_cleanup
411 static const struct hda_pcm_stream ad198x_pcm_digital_playback = {
415 .nid = 0, /* fill later */
417 .open = ad198x_dig_playback_pcm_open,
418 .close = ad198x_dig_playback_pcm_close,
419 .prepare = ad198x_dig_playback_pcm_prepare,
420 .cleanup = ad198x_dig_playback_pcm_cleanup
424 static const struct hda_pcm_stream ad198x_pcm_digital_capture = {
428 /* NID is set in alc_build_pcms */
431 static int ad198x_build_pcms(struct hda_codec *codec)
433 struct ad198x_spec *spec = codec->spec;
434 struct hda_pcm *info = spec->pcm_rec;
437 codec->pcm_info = info;
439 info->name = "AD198x Analog";
440 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
441 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
442 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
443 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
444 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
445 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
447 if (spec->multiout.dig_out_nid) {
450 codec->spdif_status_reset = 1;
451 info->name = "AD198x Digital";
452 info->pcm_type = HDA_PCM_TYPE_SPDIF;
453 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
454 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
455 if (spec->dig_in_nid) {
456 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
457 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
463 #endif /* ENABLE_AD_STATIC_QUIRKS */
465 static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
468 if (snd_hda_query_pin_caps(codec, front) & AC_PINCAP_EAPD)
469 snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE,
470 !codec->inv_eapd ? 0x00 : 0x02);
471 if (snd_hda_query_pin_caps(codec, hp) & AC_PINCAP_EAPD)
472 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE,
473 !codec->inv_eapd ? 0x00 : 0x02);
476 static void ad198x_power_eapd(struct hda_codec *codec)
478 /* We currently only handle front, HP */
479 switch (codec->vendor_id) {
492 ad198x_power_eapd_write(codec, 0x12, 0x11);
496 ad198x_power_eapd_write(codec, 0x05, 0x06);
499 ad198x_power_eapd_write(codec, 0x1b, 0x1a);
504 static void ad198x_shutup(struct hda_codec *codec)
506 snd_hda_shutup_pins(codec);
507 ad198x_power_eapd(codec);
510 static void ad198x_free(struct hda_codec *codec)
512 struct ad198x_spec *spec = codec->spec;
517 snd_hda_gen_spec_free(&spec->gen);
519 snd_hda_detach_beep_device(codec);
523 static int ad198x_suspend(struct hda_codec *codec)
525 ad198x_shutup(codec);
530 #ifdef ENABLE_AD_STATIC_QUIRKS
531 static const struct hda_codec_ops ad198x_patch_ops = {
532 .build_controls = ad198x_build_controls,
533 .build_pcms = ad198x_build_pcms,
537 .check_power_status = ad198x_check_power_status,
538 .suspend = ad198x_suspend,
540 .reboot_notify = ad198x_shutup,
546 * the private value = nid
548 #define ad198x_eapd_info snd_ctl_boolean_mono_info
550 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
551 struct snd_ctl_elem_value *ucontrol)
553 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
554 struct ad198x_spec *spec = codec->spec;
556 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
558 ucontrol->value.integer.value[0] = spec->cur_eapd;
562 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
563 struct snd_ctl_elem_value *ucontrol)
565 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
566 struct ad198x_spec *spec = codec->spec;
567 hda_nid_t nid = kcontrol->private_value & 0xff;
569 eapd = !!ucontrol->value.integer.value[0];
572 if (eapd == spec->cur_eapd)
574 spec->cur_eapd = eapd;
575 snd_hda_codec_write_cache(codec, nid,
576 0, AC_VERB_SET_EAPD_BTLENABLE,
581 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
582 struct snd_ctl_elem_info *uinfo);
583 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
584 struct snd_ctl_elem_value *ucontrol);
585 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
586 struct snd_ctl_elem_value *ucontrol);
587 #endif /* ENABLE_AD_STATIC_QUIRKS */
591 * Automatic parse of I/O pins from the BIOS configuration
594 static int ad198x_auto_build_controls(struct hda_codec *codec)
598 err = snd_hda_gen_build_controls(codec);
601 err = create_beep_ctls(codec);
607 static const struct hda_codec_ops ad198x_auto_patch_ops = {
608 .build_controls = ad198x_auto_build_controls,
609 .build_pcms = snd_hda_gen_build_pcms,
610 .init = snd_hda_gen_init,
611 .free = snd_hda_gen_free,
612 .unsol_event = snd_hda_jack_unsol_event,
614 .check_power_status = snd_hda_gen_check_power_status,
615 .suspend = ad198x_suspend,
617 .reboot_notify = ad198x_shutup,
621 static int ad198x_parse_auto_config(struct hda_codec *codec)
623 struct ad198x_spec *spec = codec->spec;
624 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
627 codec->spdif_status_reset = 1;
628 codec->no_trigger_sense = 1;
629 codec->no_sticky_stream = 1;
631 spec->gen.indep_hp = 1;
633 err = snd_hda_parse_pin_defcfg(codec, cfg, NULL, 0);
636 err = snd_hda_gen_parse_auto_config(codec, cfg);
640 codec->patch_ops = ad198x_auto_patch_ops;
649 #ifdef ENABLE_AD_STATIC_QUIRKS
650 #define AD1986A_SPDIF_OUT 0x02
651 #define AD1986A_FRONT_DAC 0x03
652 #define AD1986A_SURR_DAC 0x04
653 #define AD1986A_CLFE_DAC 0x05
654 #define AD1986A_ADC 0x06
656 static const hda_nid_t ad1986a_dac_nids[3] = {
657 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
659 static const hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
660 static const hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
662 static const struct hda_input_mux ad1986a_capture_source = {
676 static const struct hda_bind_ctls ad1986a_bind_pcm_vol = {
677 .ops = &snd_hda_bind_vol,
679 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
680 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
681 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
686 static const struct hda_bind_ctls ad1986a_bind_pcm_sw = {
687 .ops = &snd_hda_bind_sw,
689 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
690 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
691 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
699 static const struct snd_kcontrol_new ad1986a_mixers[] = {
701 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
703 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
704 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
705 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
706 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
707 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
708 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
709 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
710 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
711 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
712 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
713 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
714 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
715 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
716 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
717 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
718 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
719 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
720 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
721 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
722 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
723 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
724 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
725 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
726 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
727 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
729 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
730 .name = "Capture Source",
731 .info = ad198x_mux_enum_info,
732 .get = ad198x_mux_enum_get,
733 .put = ad198x_mux_enum_put,
735 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
739 /* additional mixers for 3stack mode */
740 static const struct snd_kcontrol_new ad1986a_3st_mixers[] = {
742 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
743 .name = "Channel Mode",
744 .info = ad198x_ch_mode_info,
745 .get = ad198x_ch_mode_get,
746 .put = ad198x_ch_mode_put,
751 /* laptop model - 2ch only */
752 static const hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
754 /* master controls both pins 0x1a and 0x1b */
755 static const struct hda_bind_ctls ad1986a_laptop_master_vol = {
756 .ops = &snd_hda_bind_vol,
758 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
759 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
764 static const struct hda_bind_ctls ad1986a_laptop_master_sw = {
765 .ops = &snd_hda_bind_sw,
767 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
768 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
773 static const struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
774 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
775 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
776 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
777 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
778 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
779 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
780 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
781 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
782 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
783 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
784 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
785 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
786 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
788 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
789 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
790 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
791 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
793 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
794 .name = "Capture Source",
795 .info = ad198x_mux_enum_info,
796 .get = ad198x_mux_enum_get,
797 .put = ad198x_mux_enum_put,
802 /* laptop-eapd model - 2ch only */
804 static const struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
808 { "Internal Mic", 0x4 },
813 static const struct hda_input_mux ad1986a_automic_capture_source = {
821 static const struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = {
822 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
823 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
827 static const struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
828 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
829 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
830 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
831 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
832 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
833 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
834 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
836 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
837 .name = "Capture Source",
838 .info = ad198x_mux_enum_info,
839 .get = ad198x_mux_enum_get,
840 .put = ad198x_mux_enum_put,
843 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
844 .name = "External Amplifier",
845 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
846 .info = ad198x_eapd_info,
847 .get = ad198x_eapd_get,
848 .put = ad198x_eapd_put,
849 .private_value = 0x1b, /* port-D */
854 static const struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {
855 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
856 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
860 /* re-connect the mic boost input according to the jack sensing */
861 static void ad1986a_automic(struct hda_codec *codec)
863 unsigned int present;
864 present = snd_hda_jack_detect(codec, 0x1f);
865 /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
866 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
870 #define AD1986A_MIC_EVENT 0x36
872 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
875 if ((res >> 26) != AD1986A_MIC_EVENT)
877 ad1986a_automic(codec);
880 static int ad1986a_automic_init(struct hda_codec *codec)
883 ad1986a_automic(codec);
887 /* laptop-automute - 2ch only */
889 static void ad1986a_update_hp(struct hda_codec *codec)
891 struct ad198x_spec *spec = codec->spec;
894 if (spec->jack_present)
895 mute = HDA_AMP_MUTE; /* mute internal speaker */
897 /* unmute internal speaker if necessary */
898 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
899 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
903 static void ad1986a_hp_automute(struct hda_codec *codec)
905 struct ad198x_spec *spec = codec->spec;
907 spec->jack_present = snd_hda_jack_detect(codec, 0x1a);
908 if (spec->inv_jack_detect)
909 spec->jack_present = !spec->jack_present;
910 ad1986a_update_hp(codec);
913 #define AD1986A_HP_EVENT 0x37
915 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
917 if ((res >> 26) != AD1986A_HP_EVENT)
919 ad1986a_hp_automute(codec);
922 static int ad1986a_hp_init(struct hda_codec *codec)
925 ad1986a_hp_automute(codec);
929 /* bind hp and internal speaker mute (with plug check) */
930 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
931 struct snd_ctl_elem_value *ucontrol)
933 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
934 int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
936 ad1986a_update_hp(codec);
940 static const struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {
941 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
943 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
944 .name = "Master Playback Switch",
945 .subdevice = HDA_SUBDEV_AMP_FLAG,
946 .info = snd_hda_mixer_amp_switch_info,
947 .get = snd_hda_mixer_amp_switch_get,
948 .put = ad1986a_hp_master_sw_put,
949 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
956 * initialization verbs
958 static const struct hda_verb ad1986a_init_verbs[] = {
959 /* Front, Surround, CLFE DAC; mute as default */
960 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
961 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
962 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
964 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
965 /* HP, Line-Out, Surround, CLFE selectors */
966 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
967 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
968 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
969 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
971 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
972 /* Mic selector: Mic 1/2 pin */
973 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
974 /* Line-in selector: Line-in */
975 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
977 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
978 /* Record selector: mic */
979 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
980 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
981 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
982 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
983 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
984 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
985 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
987 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
988 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
989 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
990 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
991 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
992 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
993 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
995 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
996 /* Front, Surround, CLFE Pins */
997 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
998 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
999 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1001 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1003 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1004 /* Line, Aux, CD, Beep-In Pin */
1005 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1006 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1007 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1008 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1009 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1013 static const struct hda_verb ad1986a_ch2_init[] = {
1014 /* Surround out -> Line In */
1015 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1016 /* Line-in selectors */
1017 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
1018 /* CLFE -> Mic in */
1019 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1020 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
1021 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
1025 static const struct hda_verb ad1986a_ch4_init[] = {
1026 /* Surround out -> Surround */
1027 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1028 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
1029 /* CLFE -> Mic in */
1030 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1031 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
1035 static const struct hda_verb ad1986a_ch6_init[] = {
1036 /* Surround out -> Surround out */
1037 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1038 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
1040 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1041 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
1045 static const struct hda_channel_mode ad1986a_modes[3] = {
1046 { 2, ad1986a_ch2_init },
1047 { 4, ad1986a_ch4_init },
1048 { 6, ad1986a_ch6_init },
1051 /* eapd initialization */
1052 static const struct hda_verb ad1986a_eapd_init_verbs[] = {
1053 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
1057 static const struct hda_verb ad1986a_automic_verbs[] = {
1058 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1059 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1060 /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
1061 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
1062 {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
1066 /* Ultra initialization */
1067 static const struct hda_verb ad1986a_ultra_init[] = {
1068 /* eapd initialization */
1069 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
1070 /* CLFE -> Mic in */
1071 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
1072 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1073 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
1077 /* pin sensing on HP jack */
1078 static const struct hda_verb ad1986a_hp_init_verbs[] = {
1079 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
1083 static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec,
1086 switch (res >> 26) {
1087 case AD1986A_HP_EVENT:
1088 ad1986a_hp_automute(codec);
1090 case AD1986A_MIC_EVENT:
1091 ad1986a_automic(codec);
1096 static int ad1986a_samsung_p50_init(struct hda_codec *codec)
1099 ad1986a_hp_automute(codec);
1100 ad1986a_automic(codec);
1111 AD1986A_LAPTOP_EAPD,
1112 AD1986A_LAPTOP_AUTOMUTE,
1115 AD1986A_SAMSUNG_P50,
1119 static const char * const ad1986a_models[AD1986A_MODELS] = {
1120 [AD1986A_AUTO] = "auto",
1121 [AD1986A_6STACK] = "6stack",
1122 [AD1986A_3STACK] = "3stack",
1123 [AD1986A_LAPTOP] = "laptop",
1124 [AD1986A_LAPTOP_EAPD] = "laptop-eapd",
1125 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
1126 [AD1986A_ULTRA] = "ultra",
1127 [AD1986A_SAMSUNG] = "samsung",
1128 [AD1986A_SAMSUNG_P50] = "samsung-p50",
1131 static const struct snd_pci_quirk ad1986a_cfg_tbl[] = {
1132 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
1133 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
1134 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
1135 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
1136 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
1137 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
1138 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
1139 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
1140 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
1141 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
1142 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
1143 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
1144 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
1145 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
1146 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
1147 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
1148 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40-10Q", AD1986A_3STACK),
1149 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
1150 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
1151 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50),
1152 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
1153 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),
1154 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
1155 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
1156 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
1157 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
1158 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
1163 static const struct hda_amp_list ad1986a_loopbacks[] = {
1164 { 0x13, HDA_OUTPUT, 0 }, /* Mic */
1165 { 0x14, HDA_OUTPUT, 0 }, /* Phone */
1166 { 0x15, HDA_OUTPUT, 0 }, /* CD */
1167 { 0x16, HDA_OUTPUT, 0 }, /* Aux */
1168 { 0x17, HDA_OUTPUT, 0 }, /* Line */
1173 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
1175 unsigned int conf = snd_hda_codec_get_pincfg(codec, nid);
1176 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
1178 #endif /* ENABLE_AD_STATIC_QUIRKS */
1180 static int alloc_ad_spec(struct hda_codec *codec)
1182 struct ad198x_spec *spec;
1184 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1188 snd_hda_gen_spec_init(&spec->gen);
1193 * AD1986A fixup codes
1196 /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
1197 static void ad_fixup_inv_jack_detect(struct hda_codec *codec,
1198 const struct hda_fixup *fix, int action)
1200 struct ad198x_spec *spec = codec->spec;
1202 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1203 codec->inv_jack_detect = 1;
1204 spec->gen.keep_eapd_on = 1;
1209 AD1986A_FIXUP_INV_JACK_DETECT,
1212 static const struct hda_fixup ad1986a_fixups[] = {
1213 [AD1986A_FIXUP_INV_JACK_DETECT] = {
1214 .type = HDA_FIXUP_FUNC,
1215 .v.func = ad_fixup_inv_jack_detect,
1219 static const struct snd_pci_quirk ad1986a_fixup_tbl[] = {
1220 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_FIXUP_INV_JACK_DETECT),
1226 static int ad1986a_parse_auto_config(struct hda_codec *codec)
1229 struct ad198x_spec *spec;
1230 static hda_nid_t preferred_pairs[] = {
1239 err = alloc_ad_spec(codec);
1244 /* AD1986A has the inverted EAPD implementation */
1245 codec->inv_eapd = 1;
1247 spec->gen.mixer_nid = 0x07;
1248 spec->gen.beep_nid = 0x19;
1249 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
1251 /* AD1986A has a hardware problem that it can't share a stream
1252 * with multiple output pins. The copy of front to surrounds
1253 * causes noisy or silent outputs at a certain timing, e.g.
1254 * changing the volume.
1255 * So, let's disable the shared stream.
1257 spec->gen.multiout.no_share_stream = 1;
1258 /* give fixed DAC/pin pairs */
1259 spec->gen.preferred_dacs = preferred_pairs;
1261 snd_hda_pick_fixup(codec, NULL, ad1986a_fixup_tbl, ad1986a_fixups);
1262 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1264 err = ad198x_parse_auto_config(codec);
1266 snd_hda_gen_free(codec);
1270 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1275 #ifdef ENABLE_AD_STATIC_QUIRKS
1276 static int patch_ad1986a(struct hda_codec *codec)
1278 struct ad198x_spec *spec;
1279 int err, board_config;
1281 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1284 if (board_config < 0) {
1285 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
1287 board_config = AD1986A_AUTO;
1290 if (board_config == AD1986A_AUTO)
1291 return ad1986a_parse_auto_config(codec);
1293 err = alloc_ad_spec(codec);
1298 err = snd_hda_attach_beep_device(codec, 0x19);
1303 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
1305 spec->multiout.max_channels = 6;
1306 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
1307 spec->multiout.dac_nids = ad1986a_dac_nids;
1308 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
1309 spec->num_adc_nids = 1;
1310 spec->adc_nids = ad1986a_adc_nids;
1311 spec->capsrc_nids = ad1986a_capsrc_nids;
1312 spec->input_mux = &ad1986a_capture_source;
1313 spec->num_mixers = 1;
1314 spec->mixers[0] = ad1986a_mixers;
1315 spec->num_init_verbs = 1;
1316 spec->init_verbs[0] = ad1986a_init_verbs;
1318 spec->loopback.amplist = ad1986a_loopbacks;
1320 spec->vmaster_nid = 0x1b;
1321 codec->inv_eapd = 1; /* AD1986A has the inverted EAPD implementation */
1323 codec->patch_ops = ad198x_patch_ops;
1325 /* override some parameters */
1326 switch (board_config) {
1327 case AD1986A_3STACK:
1328 spec->num_mixers = 2;
1329 spec->mixers[1] = ad1986a_3st_mixers;
1330 spec->num_init_verbs = 2;
1331 spec->init_verbs[1] = ad1986a_ch2_init;
1332 spec->channel_mode = ad1986a_modes;
1333 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1334 spec->need_dac_fix = 1;
1335 spec->multiout.max_channels = 2;
1336 spec->multiout.num_dacs = 1;
1338 case AD1986A_LAPTOP:
1339 spec->mixers[0] = ad1986a_laptop_mixers;
1340 spec->multiout.max_channels = 2;
1341 spec->multiout.num_dacs = 1;
1342 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1344 case AD1986A_LAPTOP_EAPD:
1345 spec->num_mixers = 3;
1346 spec->mixers[0] = ad1986a_laptop_master_mixers;
1347 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1348 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1349 spec->num_init_verbs = 2;
1350 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1351 spec->multiout.max_channels = 2;
1352 spec->multiout.num_dacs = 1;
1353 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1354 if (!is_jack_available(codec, 0x25))
1355 spec->multiout.dig_out_nid = 0;
1356 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1358 case AD1986A_SAMSUNG:
1359 spec->num_mixers = 2;
1360 spec->mixers[0] = ad1986a_laptop_master_mixers;
1361 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1362 spec->num_init_verbs = 3;
1363 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1364 spec->init_verbs[2] = ad1986a_automic_verbs;
1365 spec->multiout.max_channels = 2;
1366 spec->multiout.num_dacs = 1;
1367 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1368 if (!is_jack_available(codec, 0x25))
1369 spec->multiout.dig_out_nid = 0;
1370 spec->input_mux = &ad1986a_automic_capture_source;
1371 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1372 codec->patch_ops.init = ad1986a_automic_init;
1374 case AD1986A_SAMSUNG_P50:
1375 spec->num_mixers = 2;
1376 spec->mixers[0] = ad1986a_automute_master_mixers;
1377 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1378 spec->num_init_verbs = 4;
1379 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1380 spec->init_verbs[2] = ad1986a_automic_verbs;
1381 spec->init_verbs[3] = ad1986a_hp_init_verbs;
1382 spec->multiout.max_channels = 2;
1383 spec->multiout.num_dacs = 1;
1384 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1385 if (!is_jack_available(codec, 0x25))
1386 spec->multiout.dig_out_nid = 0;
1387 spec->input_mux = &ad1986a_automic_capture_source;
1388 codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event;
1389 codec->patch_ops.init = ad1986a_samsung_p50_init;
1391 case AD1986A_LAPTOP_AUTOMUTE:
1392 spec->num_mixers = 3;
1393 spec->mixers[0] = ad1986a_automute_master_mixers;
1394 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1395 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1396 spec->num_init_verbs = 3;
1397 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1398 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1399 spec->multiout.max_channels = 2;
1400 spec->multiout.num_dacs = 1;
1401 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1402 if (!is_jack_available(codec, 0x25))
1403 spec->multiout.dig_out_nid = 0;
1404 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1405 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1406 codec->patch_ops.init = ad1986a_hp_init;
1407 /* Lenovo N100 seems to report the reversed bit
1408 * for HP jack-sensing
1410 spec->inv_jack_detect = 1;
1413 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1414 spec->num_init_verbs = 2;
1415 spec->init_verbs[1] = ad1986a_ultra_init;
1416 spec->multiout.max_channels = 2;
1417 spec->multiout.num_dacs = 1;
1418 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1419 spec->multiout.dig_out_nid = 0;
1423 /* AD1986A has a hardware problem that it can't share a stream
1424 * with multiple output pins. The copy of front to surrounds
1425 * causes noisy or silent outputs at a certain timing, e.g.
1426 * changing the volume.
1427 * So, let's disable the shared stream.
1429 spec->multiout.no_share_stream = 1;
1431 codec->no_trigger_sense = 1;
1432 codec->no_sticky_stream = 1;
1436 #else /* ENABLE_AD_STATIC_QUIRKS */
1437 #define patch_ad1986a ad1986a_parse_auto_config
1438 #endif /* ENABLE_AD_STATIC_QUIRKS */
1444 #ifdef ENABLE_AD_STATIC_QUIRKS
1445 #define AD1983_SPDIF_OUT 0x02
1446 #define AD1983_DAC 0x03
1447 #define AD1983_ADC 0x04
1449 static const hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1450 static const hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1451 static const hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1453 static const struct hda_input_mux ad1983_capture_source = {
1459 { "Mix Mono", 0x3 },
1464 * SPDIF playback route
1466 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1468 static const char * const texts[] = { "PCM", "ADC" };
1470 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1472 uinfo->value.enumerated.items = 2;
1473 if (uinfo->value.enumerated.item > 1)
1474 uinfo->value.enumerated.item = 1;
1475 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1479 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1481 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1482 struct ad198x_spec *spec = codec->spec;
1484 ucontrol->value.enumerated.item[0] = spec->spdif_route;
1488 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1490 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1491 struct ad198x_spec *spec = codec->spec;
1493 if (ucontrol->value.enumerated.item[0] > 1)
1495 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1496 spec->spdif_route = ucontrol->value.enumerated.item[0];
1497 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1498 AC_VERB_SET_CONNECT_SEL,
1505 static const struct snd_kcontrol_new ad1983_mixers[] = {
1506 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1507 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1508 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1509 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1510 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1511 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1512 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1513 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1514 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1515 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1516 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1517 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1518 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0c, 0x0, HDA_OUTPUT),
1519 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1520 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1522 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1523 .name = "Capture Source",
1524 .info = ad198x_mux_enum_info,
1525 .get = ad198x_mux_enum_get,
1526 .put = ad198x_mux_enum_put,
1529 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1530 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1531 .info = ad1983_spdif_route_info,
1532 .get = ad1983_spdif_route_get,
1533 .put = ad1983_spdif_route_put,
1538 static const struct hda_verb ad1983_init_verbs[] = {
1539 /* Front, HP, Mono; mute as default */
1540 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1541 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1542 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1543 /* Beep, PCM, Mic, Line-In: mute */
1544 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1545 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1546 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1547 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1548 /* Front, HP selectors; from Mix */
1549 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1550 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1551 /* Mono selector; from Mix */
1552 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1553 /* Mic selector; Mic */
1554 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1555 /* Line-in selector: Line-in */
1556 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1557 /* Mic boost: 0dB */
1558 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1559 /* Record selector: mic */
1560 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1561 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1562 /* SPDIF route: PCM */
1563 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1565 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1567 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1569 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1571 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1573 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1578 static const struct hda_amp_list ad1983_loopbacks[] = {
1579 { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1580 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1592 static const char * const ad1983_models[AD1983_MODELS] = {
1593 [AD1983_AUTO] = "auto",
1594 [AD1983_BASIC] = "basic",
1596 #endif /* ENABLE_AD_STATIC_QUIRKS */
1600 * SPDIF mux control for AD1983 auto-parser
1602 static int ad1983_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
1603 struct snd_ctl_elem_info *uinfo)
1605 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1606 struct ad198x_spec *spec = codec->spec;
1607 static const char * const texts2[] = { "PCM", "ADC" };
1608 static const char * const texts3[] = { "PCM", "ADC1", "ADC2" };
1609 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
1610 int num_conns = snd_hda_get_num_conns(codec, dig_out);
1613 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts2);
1614 else if (num_conns == 3)
1615 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
1620 static int ad1983_auto_smux_enum_get(struct snd_kcontrol *kcontrol,
1621 struct snd_ctl_elem_value *ucontrol)
1623 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1624 struct ad198x_spec *spec = codec->spec;
1626 ucontrol->value.enumerated.item[0] = spec->cur_smux;
1630 static int ad1983_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
1631 struct snd_ctl_elem_value *ucontrol)
1633 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1634 struct ad198x_spec *spec = codec->spec;
1635 unsigned int val = ucontrol->value.enumerated.item[0];
1636 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
1637 int num_conns = snd_hda_get_num_conns(codec, dig_out);
1639 if (val >= num_conns)
1641 if (spec->cur_smux == val)
1643 spec->cur_smux = val;
1644 snd_hda_codec_write_cache(codec, dig_out, 0,
1645 AC_VERB_SET_CONNECT_SEL, val);
1649 static struct snd_kcontrol_new ad1983_auto_smux_mixer = {
1650 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1651 .name = "IEC958 Playback Source",
1652 .info = ad1983_auto_smux_enum_info,
1653 .get = ad1983_auto_smux_enum_get,
1654 .put = ad1983_auto_smux_enum_put,
1657 static int ad1983_add_spdif_mux_ctl(struct hda_codec *codec)
1659 struct ad198x_spec *spec = codec->spec;
1660 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
1665 num_conns = snd_hda_get_num_conns(codec, dig_out);
1666 if (num_conns != 2 && num_conns != 3)
1668 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1983_auto_smux_mixer))
1673 static int ad1983_parse_auto_config(struct hda_codec *codec)
1675 struct ad198x_spec *spec;
1678 err = alloc_ad_spec(codec);
1683 spec->gen.mixer_nid = 0x0e;
1684 spec->gen.beep_nid = 0x10;
1685 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1686 err = ad198x_parse_auto_config(codec);
1689 err = ad1983_add_spdif_mux_ctl(codec);
1695 snd_hda_gen_free(codec);
1699 #ifdef ENABLE_AD_STATIC_QUIRKS
1700 static int patch_ad1983(struct hda_codec *codec)
1702 struct ad198x_spec *spec;
1706 board_config = snd_hda_check_board_config(codec, AD1983_MODELS,
1707 ad1983_models, NULL);
1708 if (board_config < 0) {
1709 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
1711 board_config = AD1983_AUTO;
1714 if (board_config == AD1983_AUTO)
1715 return ad1983_parse_auto_config(codec);
1717 err = alloc_ad_spec(codec);
1722 err = snd_hda_attach_beep_device(codec, 0x10);
1727 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1729 spec->multiout.max_channels = 2;
1730 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1731 spec->multiout.dac_nids = ad1983_dac_nids;
1732 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1733 spec->num_adc_nids = 1;
1734 spec->adc_nids = ad1983_adc_nids;
1735 spec->capsrc_nids = ad1983_capsrc_nids;
1736 spec->input_mux = &ad1983_capture_source;
1737 spec->num_mixers = 1;
1738 spec->mixers[0] = ad1983_mixers;
1739 spec->num_init_verbs = 1;
1740 spec->init_verbs[0] = ad1983_init_verbs;
1741 spec->spdif_route = 0;
1743 spec->loopback.amplist = ad1983_loopbacks;
1745 spec->vmaster_nid = 0x05;
1747 codec->patch_ops = ad198x_patch_ops;
1749 codec->no_trigger_sense = 1;
1750 codec->no_sticky_stream = 1;
1754 #else /* ENABLE_AD_STATIC_QUIRKS */
1755 #define patch_ad1983 ad1983_parse_auto_config
1756 #endif /* ENABLE_AD_STATIC_QUIRKS */
1760 * AD1981 HD specific
1763 #ifdef ENABLE_AD_STATIC_QUIRKS
1764 #define AD1981_SPDIF_OUT 0x02
1765 #define AD1981_DAC 0x03
1766 #define AD1981_ADC 0x04
1768 static const hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1769 static const hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1770 static const hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1772 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1773 static const struct hda_input_mux ad1981_capture_source = {
1776 { "Front Mic", 0x0 },
1779 { "Mix Mono", 0x3 },
1786 static const struct snd_kcontrol_new ad1981_mixers[] = {
1787 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1788 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1789 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1790 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1791 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1792 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1793 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1794 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1795 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1796 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1797 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1798 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1799 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1800 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1801 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1802 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1803 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1804 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1805 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
1806 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x0, HDA_INPUT),
1807 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1808 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1810 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1811 .name = "Capture Source",
1812 .info = ad198x_mux_enum_info,
1813 .get = ad198x_mux_enum_get,
1814 .put = ad198x_mux_enum_put,
1816 /* identical with AD1983 */
1818 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1819 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1820 .info = ad1983_spdif_route_info,
1821 .get = ad1983_spdif_route_get,
1822 .put = ad1983_spdif_route_put,
1827 static const struct hda_verb ad1981_init_verbs[] = {
1828 /* Front, HP, Mono; mute as default */
1829 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1830 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1831 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1832 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1833 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1834 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1835 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1836 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1837 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1838 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1839 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1840 /* Front, HP selectors; from Mix */
1841 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1842 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1843 /* Mono selector; from Mix */
1844 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1845 /* Mic Mixer; select Front Mic */
1846 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1847 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1848 /* Mic boost: 0dB */
1849 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1850 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1851 /* Record selector: Front mic */
1852 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1853 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1854 /* SPDIF route: PCM */
1855 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1857 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1859 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1861 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1862 /* Front & Rear Mic Pins */
1863 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1864 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1866 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1868 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1869 /* Line-Out as Input: disabled */
1870 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1875 static const struct hda_amp_list ad1981_loopbacks[] = {
1876 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1877 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1878 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1879 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1880 { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1886 * Patch for HP nx6320
1888 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1889 * speaker output enabled _and_ mute-LED off.
1892 #define AD1981_HP_EVENT 0x37
1893 #define AD1981_MIC_EVENT 0x38
1895 static const struct hda_verb ad1981_hp_init_verbs[] = {
1896 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1897 /* pin sensing on HP and Mic jacks */
1898 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1899 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1903 /* turn on/off EAPD (+ mute HP) as a master switch */
1904 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1905 struct snd_ctl_elem_value *ucontrol)
1907 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1908 struct ad198x_spec *spec = codec->spec;
1910 if (! ad198x_eapd_put(kcontrol, ucontrol))
1912 /* change speaker pin appropriately */
1913 snd_hda_set_pin_ctl(codec, 0x05, spec->cur_eapd ? PIN_OUT : 0);
1914 /* toggle HP mute appropriately */
1915 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1917 spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1921 /* bind volumes of both NID 0x05 and 0x06 */
1922 static const struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1923 .ops = &snd_hda_bind_vol,
1925 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1926 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1931 /* mute internal speaker if HP is plugged */
1932 static void ad1981_hp_automute(struct hda_codec *codec)
1934 unsigned int present;
1936 present = snd_hda_jack_detect(codec, 0x06);
1937 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1938 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1941 /* toggle input of built-in and mic jack appropriately */
1942 static void ad1981_hp_automic(struct hda_codec *codec)
1944 static const struct hda_verb mic_jack_on[] = {
1945 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1946 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1949 static const struct hda_verb mic_jack_off[] = {
1950 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1951 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1954 unsigned int present;
1956 present = snd_hda_jack_detect(codec, 0x08);
1958 snd_hda_sequence_write(codec, mic_jack_on);
1960 snd_hda_sequence_write(codec, mic_jack_off);
1963 /* unsolicited event for HP jack sensing */
1964 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1969 case AD1981_HP_EVENT:
1970 ad1981_hp_automute(codec);
1972 case AD1981_MIC_EVENT:
1973 ad1981_hp_automic(codec);
1978 static const struct hda_input_mux ad1981_hp_capture_source = {
1982 { "Dock Mic", 0x1 },
1987 static const struct snd_kcontrol_new ad1981_hp_mixers[] = {
1988 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1990 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1991 .subdevice = HDA_SUBDEV_NID_FLAG | 0x05,
1992 .name = "Master Playback Switch",
1993 .info = ad198x_eapd_info,
1994 .get = ad198x_eapd_get,
1995 .put = ad1981_hp_master_sw_put,
1996 .private_value = 0x05,
1998 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1999 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
2001 /* FIXME: analog mic/line loopback doesn't work with my tests...
2002 * (although recording is OK)
2004 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
2005 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
2006 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
2007 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
2008 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
2009 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
2010 /* FIXME: does this laptop have analog CD connection? */
2011 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2012 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
2014 HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
2015 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x18, 0x0, HDA_INPUT),
2016 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
2017 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
2019 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2020 .name = "Capture Source",
2021 .info = ad198x_mux_enum_info,
2022 .get = ad198x_mux_enum_get,
2023 .put = ad198x_mux_enum_put,
2028 /* initialize jack-sensing, too */
2029 static int ad1981_hp_init(struct hda_codec *codec)
2032 ad1981_hp_automute(codec);
2033 ad1981_hp_automic(codec);
2037 /* configuration for Toshiba Laptops */
2038 static const struct hda_verb ad1981_toshiba_init_verbs[] = {
2039 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
2040 /* pin sensing on HP and Mic jacks */
2041 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
2042 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
2046 static const struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
2047 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
2048 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
2052 /* configuration for Lenovo Thinkpad T60 */
2053 static const struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
2054 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2055 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
2056 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
2057 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
2058 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
2059 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
2060 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2061 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
2062 HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
2063 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
2064 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
2066 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2067 .name = "Capture Source",
2068 .info = ad198x_mux_enum_info,
2069 .get = ad198x_mux_enum_get,
2070 .put = ad198x_mux_enum_put,
2072 /* identical with AD1983 */
2074 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2075 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
2076 .info = ad1983_spdif_route_info,
2077 .get = ad1983_spdif_route_get,
2078 .put = ad1983_spdif_route_put,
2083 static const struct hda_input_mux ad1981_thinkpad_capture_source = {
2102 static const char * const ad1981_models[AD1981_MODELS] = {
2103 [AD1981_AUTO] = "auto",
2105 [AD1981_THINKPAD] = "thinkpad",
2106 [AD1981_BASIC] = "basic",
2107 [AD1981_TOSHIBA] = "toshiba"
2110 static const struct snd_pci_quirk ad1981_cfg_tbl[] = {
2111 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
2112 SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
2114 SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP),
2115 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
2116 /* Lenovo Thinkpad T60/X60/Z6xx */
2117 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD),
2118 /* HP nx6320 (reversed SSID, H/W bug) */
2119 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
2122 #endif /* ENABLE_AD_STATIC_QUIRKS */
2125 /* follow EAPD via vmaster hook */
2126 static void ad_vmaster_eapd_hook(void *private_data, int enabled)
2128 struct hda_codec *codec = private_data;
2129 struct ad198x_spec *spec = codec->spec;
2131 if (!spec->eapd_nid)
2133 snd_hda_codec_update_cache(codec, spec->eapd_nid, 0,
2134 AC_VERB_SET_EAPD_BTLENABLE,
2135 enabled ? 0x02 : 0x00);
2138 static void ad1981_fixup_hp_eapd(struct hda_codec *codec,
2139 const struct hda_fixup *fix, int action)
2141 struct ad198x_spec *spec = codec->spec;
2143 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2144 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;
2145 spec->eapd_nid = 0x05;
2149 /* set the upper-limit for mixer amp to 0dB for avoiding the possible
2150 * damage by overloading
2152 static void ad1981_fixup_amp_override(struct hda_codec *codec,
2153 const struct hda_fixup *fix, int action)
2155 if (action == HDA_FIXUP_ACT_PRE_PROBE)
2156 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
2157 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
2158 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2159 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2160 (1 << AC_AMPCAP_MUTE_SHIFT));
2164 AD1981_FIXUP_AMP_OVERRIDE,
2165 AD1981_FIXUP_HP_EAPD,
2168 static const struct hda_fixup ad1981_fixups[] = {
2169 [AD1981_FIXUP_AMP_OVERRIDE] = {
2170 .type = HDA_FIXUP_FUNC,
2171 .v.func = ad1981_fixup_amp_override,
2173 [AD1981_FIXUP_HP_EAPD] = {
2174 .type = HDA_FIXUP_FUNC,
2175 .v.func = ad1981_fixup_hp_eapd,
2177 .chain_id = AD1981_FIXUP_AMP_OVERRIDE,
2181 static const struct snd_pci_quirk ad1981_fixup_tbl[] = {
2182 SND_PCI_QUIRK_VENDOR(0x1014, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE),
2183 SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1981_FIXUP_HP_EAPD),
2184 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE),
2185 /* HP nx6320 (reversed SSID, H/W bug) */
2186 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_FIXUP_HP_EAPD),
2190 static int ad1981_parse_auto_config(struct hda_codec *codec)
2192 struct ad198x_spec *spec;
2195 err = alloc_ad_spec(codec);
2200 spec->gen.mixer_nid = 0x0e;
2201 spec->gen.beep_nid = 0x10;
2202 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
2204 snd_hda_pick_fixup(codec, NULL, ad1981_fixup_tbl, ad1981_fixups);
2205 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2207 err = ad198x_parse_auto_config(codec);
2210 err = ad1983_add_spdif_mux_ctl(codec);
2214 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2219 snd_hda_gen_free(codec);
2223 #ifdef ENABLE_AD_STATIC_QUIRKS
2224 static int patch_ad1981(struct hda_codec *codec)
2226 struct ad198x_spec *spec;
2227 int err, board_config;
2229 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
2232 if (board_config < 0) {
2233 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
2235 board_config = AD1981_AUTO;
2238 if (board_config == AD1981_AUTO)
2239 return ad1981_parse_auto_config(codec);
2241 err = alloc_ad_spec(codec);
2246 err = snd_hda_attach_beep_device(codec, 0x10);
2251 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
2253 spec->multiout.max_channels = 2;
2254 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
2255 spec->multiout.dac_nids = ad1981_dac_nids;
2256 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
2257 spec->num_adc_nids = 1;
2258 spec->adc_nids = ad1981_adc_nids;
2259 spec->capsrc_nids = ad1981_capsrc_nids;
2260 spec->input_mux = &ad1981_capture_source;
2261 spec->num_mixers = 1;
2262 spec->mixers[0] = ad1981_mixers;
2263 spec->num_init_verbs = 1;
2264 spec->init_verbs[0] = ad1981_init_verbs;
2265 spec->spdif_route = 0;
2267 spec->loopback.amplist = ad1981_loopbacks;
2269 spec->vmaster_nid = 0x05;
2271 codec->patch_ops = ad198x_patch_ops;
2273 /* override some parameters */
2274 switch (board_config) {
2276 spec->mixers[0] = ad1981_hp_mixers;
2277 spec->num_init_verbs = 2;
2278 spec->init_verbs[1] = ad1981_hp_init_verbs;
2279 if (!is_jack_available(codec, 0x0a))
2280 spec->multiout.dig_out_nid = 0;
2281 spec->input_mux = &ad1981_hp_capture_source;
2283 codec->patch_ops.init = ad1981_hp_init;
2284 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
2285 /* set the upper-limit for mixer amp to 0dB for avoiding the
2286 * possible damage by overloading
2288 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
2289 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
2290 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2291 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2292 (1 << AC_AMPCAP_MUTE_SHIFT));
2294 case AD1981_THINKPAD:
2295 spec->mixers[0] = ad1981_thinkpad_mixers;
2296 spec->input_mux = &ad1981_thinkpad_capture_source;
2297 /* set the upper-limit for mixer amp to 0dB for avoiding the
2298 * possible damage by overloading
2300 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
2301 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
2302 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2303 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2304 (1 << AC_AMPCAP_MUTE_SHIFT));
2306 case AD1981_TOSHIBA:
2307 spec->mixers[0] = ad1981_hp_mixers;
2308 spec->mixers[1] = ad1981_toshiba_mixers;
2309 spec->num_init_verbs = 2;
2310 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
2311 spec->multiout.dig_out_nid = 0;
2312 spec->input_mux = &ad1981_hp_capture_source;
2313 codec->patch_ops.init = ad1981_hp_init;
2314 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
2318 codec->no_trigger_sense = 1;
2319 codec->no_sticky_stream = 1;
2323 #else /* ENABLE_AD_STATIC_QUIRKS */
2324 #define patch_ad1981 ad1981_parse_auto_config
2325 #endif /* ENABLE_AD_STATIC_QUIRKS */
2331 * Output pins and routes
2333 * Pin Mix Sel DAC (*)
2334 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
2335 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
2336 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
2337 * port-D 0x12 (mute/hp) <- 0x29 <- 04
2338 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
2339 * port-F 0x16 (mute) <- 0x2a <- 06
2340 * port-G 0x24 (mute) <- 0x27 <- 05
2341 * port-H 0x25 (mute) <- 0x28 <- 0a
2342 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
2344 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
2345 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
2347 * Input pins and routes
2349 * pin boost mix input # / adc input #
2350 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
2351 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
2352 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
2353 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
2354 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
2355 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
2356 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
2357 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
2361 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
2362 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
2364 * Inputs of Analog Mix (0x20)
2365 * 0:Port-B (front mic)
2366 * 1:Port-C/G/H (line-in)
2368 * 3:Port-D (line-in/2)
2369 * 4:Port-E/G/H (mic-in)
2370 * 5:Port-F (mic2-in)
2376 * 1:Port-B (front mic-in)
2377 * 2:Port-C (line-in)
2378 * 3:Port-F (mic2-in)
2383 * 8:Port-D (line-in/2)
2386 * Proposed pin assignments by the datasheet
2389 * Port-A front headphone
2399 * Port-A front headphone
2401 * C rear line-in/surround
2403 * E rear mic-in/CLFE
2409 * D internal speaker (with EAPD)
2410 * E/F quad mic array
2414 #ifdef ENABLE_AD_STATIC_QUIRKS
2427 /* reivision id to check workarounds */
2428 #define AD1988A_REV2 0x100200
2430 #define is_rev2(codec) \
2431 ((codec)->vendor_id == 0x11d41988 && \
2432 (codec)->revision_id == AD1988A_REV2)
2438 static const hda_nid_t ad1988_6stack_dac_nids[4] = {
2439 0x04, 0x06, 0x05, 0x0a
2442 static const hda_nid_t ad1988_3stack_dac_nids[3] = {
2446 /* for AD1988A revision-2, DAC2-4 are swapped */
2447 static const hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
2448 0x04, 0x05, 0x0a, 0x06
2451 static const hda_nid_t ad1988_alt_dac_nid[1] = {
2455 static const hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
2459 static const hda_nid_t ad1988_adc_nids[3] = {
2463 static const hda_nid_t ad1988_capsrc_nids[3] = {
2467 #define AD1988_SPDIF_OUT 0x02
2468 #define AD1988_SPDIF_OUT_HDMI 0x0b
2469 #define AD1988_SPDIF_IN 0x07
2471 static const hda_nid_t ad1989b_slave_dig_outs[] = {
2472 AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
2475 static const struct hda_input_mux ad1988_6stack_capture_source = {
2478 { "Front Mic", 0x1 }, /* port-B */
2479 { "Line", 0x2 }, /* port-C */
2480 { "Mic", 0x4 }, /* port-E */
2486 static const struct hda_input_mux ad1988_laptop_capture_source = {
2489 { "Mic/Line", 0x1 }, /* port-B */
2497 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
2498 struct snd_ctl_elem_info *uinfo)
2500 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2501 struct ad198x_spec *spec = codec->spec;
2502 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
2503 spec->num_channel_mode);
2506 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
2507 struct snd_ctl_elem_value *ucontrol)
2509 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2510 struct ad198x_spec *spec = codec->spec;
2511 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
2512 spec->num_channel_mode, spec->multiout.max_channels);
2515 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
2516 struct snd_ctl_elem_value *ucontrol)
2518 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2519 struct ad198x_spec *spec = codec->spec;
2520 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
2521 spec->num_channel_mode,
2522 &spec->multiout.max_channels);
2523 if (err >= 0 && spec->need_dac_fix)
2524 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2529 static const struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
2530 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2531 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2532 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2533 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2534 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2538 static const struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
2539 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2540 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2541 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2542 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
2543 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2547 static const struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
2548 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
2549 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2550 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
2551 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
2552 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
2553 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
2554 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2555 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2557 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2558 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2559 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2560 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2561 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2562 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2563 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2564 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2566 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2567 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2569 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
2570 HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
2575 static const struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
2576 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2577 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2578 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2579 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2583 static const struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
2584 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2585 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2586 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
2587 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
2591 static const struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
2592 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
2593 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2594 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
2595 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
2596 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
2597 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2598 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2600 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2601 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2602 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2603 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2604 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2605 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2606 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2607 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2609 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2610 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2612 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
2613 HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
2615 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2616 .name = "Channel Mode",
2617 .info = ad198x_ch_mode_info,
2618 .get = ad198x_ch_mode_get,
2619 .put = ad198x_ch_mode_put,
2626 static const struct snd_kcontrol_new ad1988_laptop_mixers[] = {
2627 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
2628 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2629 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
2630 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2632 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2633 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2634 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2635 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2636 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2637 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2639 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2640 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2642 HDA_CODEC_VOLUME("Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
2645 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2646 .name = "External Amplifier",
2647 .subdevice = HDA_SUBDEV_NID_FLAG | 0x12,
2648 .info = ad198x_eapd_info,
2649 .get = ad198x_eapd_get,
2650 .put = ad198x_eapd_put,
2651 .private_value = 0x12, /* port-D */
2658 static const struct snd_kcontrol_new ad1988_capture_mixers[] = {
2659 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2660 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2661 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2662 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2663 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2664 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2666 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2667 /* The multiple "Capture Source" controls confuse alsamixer
2668 * So call somewhat different..
2670 /* .name = "Capture Source", */
2671 .name = "Input Source",
2673 .info = ad198x_mux_enum_info,
2674 .get = ad198x_mux_enum_get,
2675 .put = ad198x_mux_enum_put,
2680 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2681 struct snd_ctl_elem_info *uinfo)
2683 static const char * const texts[] = {
2684 "PCM", "ADC1", "ADC2", "ADC3"
2686 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2688 uinfo->value.enumerated.items = 4;
2689 if (uinfo->value.enumerated.item >= 4)
2690 uinfo->value.enumerated.item = 3;
2691 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2695 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2696 struct snd_ctl_elem_value *ucontrol)
2698 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2701 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2704 ucontrol->value.enumerated.item[0] = 0;
2706 sel = snd_hda_codec_read(codec, 0x0b, 0,
2707 AC_VERB_GET_CONNECT_SEL, 0);
2712 ucontrol->value.enumerated.item[0] = sel;
2717 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2718 struct snd_ctl_elem_value *ucontrol)
2720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2721 unsigned int val, sel;
2724 val = ucontrol->value.enumerated.item[0];
2728 sel = snd_hda_codec_read(codec, 0x1d, 0,
2729 AC_VERB_GET_AMP_GAIN_MUTE,
2731 change = sel & 0x80;
2733 snd_hda_codec_write_cache(codec, 0x1d, 0,
2734 AC_VERB_SET_AMP_GAIN_MUTE,
2736 snd_hda_codec_write_cache(codec, 0x1d, 0,
2737 AC_VERB_SET_AMP_GAIN_MUTE,
2741 sel = snd_hda_codec_read(codec, 0x1d, 0,
2742 AC_VERB_GET_AMP_GAIN_MUTE,
2743 AC_AMP_GET_INPUT | 0x01);
2744 change = sel & 0x80;
2746 snd_hda_codec_write_cache(codec, 0x1d, 0,
2747 AC_VERB_SET_AMP_GAIN_MUTE,
2749 snd_hda_codec_write_cache(codec, 0x1d, 0,
2750 AC_VERB_SET_AMP_GAIN_MUTE,
2753 sel = snd_hda_codec_read(codec, 0x0b, 0,
2754 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2755 change |= sel != val;
2757 snd_hda_codec_write_cache(codec, 0x0b, 0,
2758 AC_VERB_SET_CONNECT_SEL,
2764 static const struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2765 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2767 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2768 .name = "IEC958 Playback Source",
2769 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
2770 .info = ad1988_spdif_playback_source_info,
2771 .get = ad1988_spdif_playback_source_get,
2772 .put = ad1988_spdif_playback_source_put,
2777 static const struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2778 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2782 static const struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2783 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2784 HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2789 * initialization verbs
2793 * for 6-stack (+dig)
2795 static const struct hda_verb ad1988_6stack_init_verbs[] = {
2796 /* Front, Surround, CLFE, side DAC; unmute as default */
2797 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2798 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2799 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2800 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2801 /* Port-A front headphon path */
2802 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
2803 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2804 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2805 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2806 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2807 /* Port-D line-out path */
2808 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2809 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2810 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2811 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2812 /* Port-F surround path */
2813 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2814 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2815 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2816 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2817 /* Port-G CLFE path */
2818 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2819 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2820 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2821 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2822 /* Port-H side path */
2823 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2824 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2825 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2826 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2828 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2829 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2830 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2831 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2832 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2833 /* Port-B front mic-in path */
2834 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2835 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2836 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2837 /* Port-C line-in path */
2838 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2839 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2840 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2841 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2842 /* Port-E mic-in path */
2843 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2844 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2845 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2846 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2847 /* Analog CD Input */
2848 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2849 /* Analog Mix output amp */
2850 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2855 static const struct hda_verb ad1988_6stack_fp_init_verbs[] = {
2856 /* Headphone; unmute as default */
2857 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2858 /* Port-A front headphon path */
2859 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
2860 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2861 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2862 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2863 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2868 static const struct hda_verb ad1988_capture_init_verbs[] = {
2869 /* mute analog mix */
2870 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2871 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2872 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2873 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2874 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2875 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2876 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2877 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2878 /* select ADCs - front-mic */
2879 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2880 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2881 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2886 static const struct hda_verb ad1988_spdif_init_verbs[] = {
2888 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2889 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2890 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2891 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2893 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2898 static const struct hda_verb ad1988_spdif_in_init_verbs[] = {
2899 /* unmute SPDIF input pin */
2900 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2904 /* AD1989 has no ADC -> SPDIF route */
2905 static const struct hda_verb ad1989_spdif_init_verbs[] = {
2906 /* SPDIF-1 out pin */
2907 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2908 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2909 /* SPDIF-2/HDMI out pin */
2910 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2911 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2916 * verbs for 3stack (+dig)
2918 static const struct hda_verb ad1988_3stack_ch2_init[] = {
2919 /* set port-C to line-in */
2920 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2921 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2922 /* set port-E to mic-in */
2923 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2924 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2928 static const struct hda_verb ad1988_3stack_ch6_init[] = {
2929 /* set port-C to surround out */
2930 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2931 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2932 /* set port-E to CLFE out */
2933 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2934 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2938 static const struct hda_channel_mode ad1988_3stack_modes[2] = {
2939 { 2, ad1988_3stack_ch2_init },
2940 { 6, ad1988_3stack_ch6_init },
2943 static const struct hda_verb ad1988_3stack_init_verbs[] = {
2944 /* Front, Surround, CLFE, side DAC; unmute as default */
2945 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2946 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2947 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2948 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2949 /* Port-A front headphon path */
2950 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
2951 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2952 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2953 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2954 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2955 /* Port-D line-out path */
2956 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2957 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2958 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2959 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2961 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2962 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2963 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2964 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2965 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2966 /* Port-B front mic-in path */
2967 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2968 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2969 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2970 /* Port-C line-in/surround path - 6ch mode as default */
2971 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2972 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2973 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2974 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2975 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2976 /* Port-E mic-in/CLFE path - 6ch mode as default */
2977 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2978 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2979 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2980 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2981 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2982 /* mute analog mix */
2983 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2984 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2985 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2986 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2987 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2988 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2989 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2990 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2991 /* select ADCs - front-mic */
2992 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2993 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2994 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2995 /* Analog Mix output amp */
2996 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3001 * verbs for laptop mode (+dig)
3003 static const struct hda_verb ad1988_laptop_hp_on[] = {
3004 /* unmute port-A and mute port-D */
3005 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
3006 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
3009 static const struct hda_verb ad1988_laptop_hp_off[] = {
3010 /* mute port-A and unmute port-D */
3011 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
3012 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
3016 #define AD1988_HP_EVENT 0x01
3018 static const struct hda_verb ad1988_laptop_init_verbs[] = {
3019 /* Front, Surround, CLFE, side DAC; unmute as default */
3020 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3021 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3022 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3023 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3024 /* Port-A front headphon path */
3025 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
3026 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3027 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3028 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3029 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3030 /* unsolicited event for pin-sense */
3031 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
3032 /* Port-D line-out path + EAPD */
3033 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3034 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3035 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3036 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3037 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
3039 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
3040 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3041 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3042 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3043 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
3044 /* Port-B mic-in path */
3045 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3046 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3047 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3048 /* Port-C docking station - try to output */
3049 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3050 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3051 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3052 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
3053 /* mute analog mix */
3054 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3055 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3056 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3057 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3058 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3059 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3060 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3061 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3062 /* select ADCs - mic */
3063 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
3064 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
3065 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3066 /* Analog Mix output amp */
3067 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3071 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
3073 if ((res >> 26) != AD1988_HP_EVENT)
3075 if (snd_hda_jack_detect(codec, 0x11))
3076 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
3078 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
3082 static const struct hda_amp_list ad1988_loopbacks[] = {
3083 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3084 { 0x20, HDA_INPUT, 1 }, /* Line */
3085 { 0x20, HDA_INPUT, 4 }, /* Mic */
3086 { 0x20, HDA_INPUT, 6 }, /* CD */
3090 #endif /* ENABLE_AD_STATIC_QUIRKS */
3092 static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
3093 struct snd_ctl_elem_info *uinfo)
3095 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3096 static const char * const texts[] = {
3097 "PCM", "ADC1", "ADC2", "ADC3",
3099 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
3102 return snd_hda_enum_helper_info(kcontrol, uinfo, num_conns, texts);
3105 static int ad1988_auto_smux_enum_get(struct snd_kcontrol *kcontrol,
3106 struct snd_ctl_elem_value *ucontrol)
3108 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3109 struct ad198x_spec *spec = codec->spec;
3111 ucontrol->value.enumerated.item[0] = spec->cur_smux;
3115 static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
3116 struct snd_ctl_elem_value *ucontrol)
3118 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3119 struct ad198x_spec *spec = codec->spec;
3120 unsigned int val = ucontrol->value.enumerated.item[0];
3121 struct nid_path *path;
3122 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
3124 if (val >= num_conns)
3126 if (spec->cur_smux == val)
3129 mutex_lock(&codec->control_mutex);
3130 codec->cached_write = 1;
3131 path = snd_hda_get_path_from_idx(codec,
3132 spec->smux_paths[spec->cur_smux]);
3134 snd_hda_activate_path(codec, path, false, true);
3135 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[val]);
3137 snd_hda_activate_path(codec, path, true, true);
3138 spec->cur_smux = val;
3139 codec->cached_write = 0;
3140 mutex_unlock(&codec->control_mutex);
3141 snd_hda_codec_flush_cache(codec); /* flush the updates */
3145 static struct snd_kcontrol_new ad1988_auto_smux_mixer = {
3146 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3147 .name = "IEC958 Playback Source",
3148 .info = ad1988_auto_smux_enum_info,
3149 .get = ad1988_auto_smux_enum_get,
3150 .put = ad1988_auto_smux_enum_put,
3153 static int ad1988_auto_init(struct hda_codec *codec)
3155 struct ad198x_spec *spec = codec->spec;
3158 err = snd_hda_gen_init(codec);
3161 if (!spec->gen.autocfg.dig_outs)
3164 for (i = 0; i < 4; i++) {
3165 struct nid_path *path;
3166 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[i]);
3168 snd_hda_activate_path(codec, path, path->active, false);
3174 static int ad1988_add_spdif_mux_ctl(struct hda_codec *codec)
3176 struct ad198x_spec *spec = codec->spec;
3178 /* we create four static faked paths, since AD codecs have odd
3179 * widget connections regarding the SPDIF out source
3181 static struct nid_path fake_paths[4] = {
3184 .path = { 0x02, 0x1d, 0x1b },
3186 .multi = { 0, 0, 0 },
3190 .path = { 0x08, 0x0b, 0x1d, 0x1b },
3191 .idx = { 0, 0, 1, 0 },
3192 .multi = { 0, 1, 0, 0 },
3196 .path = { 0x09, 0x0b, 0x1d, 0x1b },
3197 .idx = { 0, 1, 1, 0 },
3198 .multi = { 0, 1, 0, 0 },
3202 .path = { 0x0f, 0x0b, 0x1d, 0x1b },
3203 .idx = { 0, 2, 1, 0 },
3204 .multi = { 0, 1, 0, 0 },
3208 /* SPDIF source mux appears to be present only on AD1988A */
3209 if (!spec->gen.autocfg.dig_outs ||
3210 get_wcaps_type(get_wcaps(codec, 0x1d)) != AC_WID_AUD_MIX)
3213 num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
3214 if (num_conns != 3 && num_conns != 4)
3217 for (i = 0; i < num_conns; i++) {
3218 struct nid_path *path = snd_array_new(&spec->gen.paths);
3221 *path = fake_paths[i];
3224 spec->smux_paths[i] = snd_hda_get_path_idx(codec, path);
3227 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1988_auto_smux_mixer))
3230 codec->patch_ops.init = ad1988_auto_init;
3238 static int ad1988_parse_auto_config(struct hda_codec *codec)
3240 struct ad198x_spec *spec;
3243 err = alloc_ad_spec(codec);
3248 spec->gen.mixer_nid = 0x20;
3249 spec->gen.mixer_merge_nid = 0x21;
3250 spec->gen.beep_nid = 0x10;
3251 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3252 err = ad198x_parse_auto_config(codec);
3255 err = ad1988_add_spdif_mux_ctl(codec);
3261 snd_hda_gen_free(codec);
3268 #ifdef ENABLE_AD_STATIC_QUIRKS
3269 static const char * const ad1988_models[AD1988_MODEL_LAST] = {
3270 [AD1988_6STACK] = "6stack",
3271 [AD1988_6STACK_DIG] = "6stack-dig",
3272 [AD1988_3STACK] = "3stack",
3273 [AD1988_3STACK_DIG] = "3stack-dig",
3274 [AD1988_LAPTOP] = "laptop",
3275 [AD1988_LAPTOP_DIG] = "laptop-dig",
3276 [AD1988_AUTO] = "auto",
3279 static const struct snd_pci_quirk ad1988_cfg_tbl[] = {
3280 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
3281 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
3282 SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
3283 SND_PCI_QUIRK(0x1043, 0x82c0, "Asus M3N-HT Deluxe", AD1988_6STACK_DIG),
3284 SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
3288 static int patch_ad1988(struct hda_codec *codec)
3290 struct ad198x_spec *spec;
3291 int err, board_config;
3293 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
3294 ad1988_models, ad1988_cfg_tbl);
3295 if (board_config < 0) {
3296 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3298 board_config = AD1988_AUTO;
3301 if (board_config == AD1988_AUTO)
3302 return ad1988_parse_auto_config(codec);
3304 err = alloc_ad_spec(codec);
3310 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
3312 err = snd_hda_attach_beep_device(codec, 0x10);
3317 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3319 if (!spec->multiout.hp_nid)
3320 spec->multiout.hp_nid = ad1988_alt_dac_nid[0];
3321 switch (board_config) {
3323 case AD1988_6STACK_DIG:
3324 spec->multiout.max_channels = 8;
3325 spec->multiout.num_dacs = 4;
3327 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
3329 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
3330 spec->input_mux = &ad1988_6stack_capture_source;
3331 spec->num_mixers = 2;
3333 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
3335 spec->mixers[0] = ad1988_6stack_mixers1;
3336 spec->mixers[1] = ad1988_6stack_mixers2;
3337 spec->num_init_verbs = 1;
3338 spec->init_verbs[0] = ad1988_6stack_init_verbs;
3339 if (board_config == AD1988_6STACK_DIG) {
3340 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3341 spec->dig_in_nid = AD1988_SPDIF_IN;
3345 case AD1988_3STACK_DIG:
3346 spec->multiout.max_channels = 6;
3347 spec->multiout.num_dacs = 3;
3349 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
3351 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3352 spec->input_mux = &ad1988_6stack_capture_source;
3353 spec->channel_mode = ad1988_3stack_modes;
3354 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
3355 spec->num_mixers = 2;
3357 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
3359 spec->mixers[0] = ad1988_3stack_mixers1;
3360 spec->mixers[1] = ad1988_3stack_mixers2;
3361 spec->num_init_verbs = 1;
3362 spec->init_verbs[0] = ad1988_3stack_init_verbs;
3363 if (board_config == AD1988_3STACK_DIG)
3364 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3367 case AD1988_LAPTOP_DIG:
3368 spec->multiout.max_channels = 2;
3369 spec->multiout.num_dacs = 1;
3370 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3371 spec->input_mux = &ad1988_laptop_capture_source;
3372 spec->num_mixers = 1;
3373 spec->mixers[0] = ad1988_laptop_mixers;
3374 codec->inv_eapd = 1; /* inverted EAPD */
3375 spec->num_init_verbs = 1;
3376 spec->init_verbs[0] = ad1988_laptop_init_verbs;
3377 if (board_config == AD1988_LAPTOP_DIG)
3378 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3382 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
3383 spec->adc_nids = ad1988_adc_nids;
3384 spec->capsrc_nids = ad1988_capsrc_nids;
3385 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
3386 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
3387 if (spec->multiout.dig_out_nid) {
3388 if (codec->vendor_id >= 0x11d4989a) {
3389 spec->mixers[spec->num_mixers++] =
3390 ad1989_spdif_out_mixers;
3391 spec->init_verbs[spec->num_init_verbs++] =
3392 ad1989_spdif_init_verbs;
3393 codec->slave_dig_outs = ad1989b_slave_dig_outs;
3395 spec->mixers[spec->num_mixers++] =
3396 ad1988_spdif_out_mixers;
3397 spec->init_verbs[spec->num_init_verbs++] =
3398 ad1988_spdif_init_verbs;
3401 if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a) {
3402 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
3403 spec->init_verbs[spec->num_init_verbs++] =
3404 ad1988_spdif_in_init_verbs;
3407 codec->patch_ops = ad198x_patch_ops;
3408 switch (board_config) {
3410 case AD1988_LAPTOP_DIG:
3411 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
3415 spec->loopback.amplist = ad1988_loopbacks;
3417 spec->vmaster_nid = 0x04;
3419 codec->no_trigger_sense = 1;
3420 codec->no_sticky_stream = 1;
3424 #else /* ENABLE_AD_STATIC_QUIRKS */
3425 #define patch_ad1988 ad1988_parse_auto_config
3426 #endif /* ENABLE_AD_STATIC_QUIRKS */
3432 * port-B - front line/mic-in
3433 * port-E - aux in/out
3434 * port-F - aux in/out
3435 * port-C - rear line/mic-in
3436 * port-D - rear line/hp-out
3437 * port-A - front line/hp-out
3439 * AD1984 = AD1884 + two digital mic-ins
3442 * For simplicity, we share the single DAC for both HP and line-outs
3443 * right now. The inidividual playbacks could be easily implemented,
3444 * but no build-up framework is given, so far.
3447 #ifdef ENABLE_AD_STATIC_QUIRKS
3448 static const hda_nid_t ad1884_dac_nids[1] = {
3452 static const hda_nid_t ad1884_adc_nids[2] = {
3456 static const hda_nid_t ad1884_capsrc_nids[2] = {
3460 #define AD1884_SPDIF_OUT 0x02
3462 static const struct hda_input_mux ad1884_capture_source = {
3465 { "Front Mic", 0x0 },
3472 static const struct snd_kcontrol_new ad1884_base_mixers[] = {
3473 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3474 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3475 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3476 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3477 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3478 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3479 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3480 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3481 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3482 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3483 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3484 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3485 HDA_CODEC_VOLUME("Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
3486 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
3487 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3488 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3489 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3490 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3492 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3493 /* The multiple "Capture Source" controls confuse alsamixer
3494 * So call somewhat different..
3496 /* .name = "Capture Source", */
3497 .name = "Input Source",
3499 .info = ad198x_mux_enum_info,
3500 .get = ad198x_mux_enum_get,
3501 .put = ad198x_mux_enum_put,
3503 /* SPDIF controls */
3504 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3507 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3508 /* identical with ad1983 */
3509 .info = ad1983_spdif_route_info,
3510 .get = ad1983_spdif_route_get,
3511 .put = ad1983_spdif_route_put,
3516 static const struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3517 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3518 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3519 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3521 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3527 * initialization verbs
3529 static const struct hda_verb ad1884_init_verbs[] = {
3530 /* DACs; mute as default */
3531 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3532 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3533 /* Port-A (HP) mixer */
3534 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3535 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3537 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3538 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3539 /* HP selector - select DAC2 */
3540 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3541 /* Port-D (Line-out) mixer */
3542 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3543 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3545 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3546 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3547 /* Mono-out mixer */
3548 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3549 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3551 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3552 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3554 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3555 /* Port-B (front mic) pin */
3556 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3557 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3558 /* Port-C (rear mic) pin */
3559 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3560 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3561 /* Analog mixer; mute as default */
3562 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3563 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3564 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3565 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3566 /* Analog Mix output amp */
3567 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3568 /* SPDIF output selector */
3569 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3570 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3575 static const struct hda_amp_list ad1884_loopbacks[] = {
3576 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3577 { 0x20, HDA_INPUT, 1 }, /* Mic */
3578 { 0x20, HDA_INPUT, 2 }, /* CD */
3579 { 0x20, HDA_INPUT, 4 }, /* Docking */
3584 static const char * const ad1884_slave_vols[] = {
3585 "PCM", "Mic", "Mono", "Front Mic", "Mic", "CD",
3586 "Internal Mic", "Dock Mic", /* "Beep", */ "IEC958",
3596 static const char * const ad1884_models[AD1884_MODELS] = {
3597 [AD1884_AUTO] = "auto",
3598 [AD1884_BASIC] = "basic",
3600 #endif /* ENABLE_AD_STATIC_QUIRKS */
3603 /* set the upper-limit for mixer amp to 0dB for avoiding the possible
3604 * damage by overloading
3606 static void ad1884_fixup_amp_override(struct hda_codec *codec,
3607 const struct hda_fixup *fix, int action)
3609 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3610 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
3611 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
3612 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3613 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3614 (1 << AC_AMPCAP_MUTE_SHIFT));
3617 static void ad1884_fixup_hp_eapd(struct hda_codec *codec,
3618 const struct hda_fixup *fix, int action)
3620 struct ad198x_spec *spec = codec->spec;
3623 case HDA_FIXUP_ACT_PRE_PROBE:
3624 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;
3626 case HDA_FIXUP_ACT_PROBE:
3627 if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3628 spec->eapd_nid = spec->gen.autocfg.line_out_pins[0];
3630 spec->eapd_nid = spec->gen.autocfg.speaker_pins[0];
3636 AD1884_FIXUP_AMP_OVERRIDE,
3637 AD1884_FIXUP_HP_EAPD,
3640 static const struct hda_fixup ad1884_fixups[] = {
3641 [AD1884_FIXUP_AMP_OVERRIDE] = {
3642 .type = HDA_FIXUP_FUNC,
3643 .v.func = ad1884_fixup_amp_override,
3645 [AD1884_FIXUP_HP_EAPD] = {
3646 .type = HDA_FIXUP_FUNC,
3647 .v.func = ad1884_fixup_hp_eapd,
3649 .chain_id = AD1884_FIXUP_AMP_OVERRIDE,
3653 static const struct snd_pci_quirk ad1884_fixup_tbl[] = {
3654 SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1884_FIXUP_HP_EAPD),
3659 static int ad1884_parse_auto_config(struct hda_codec *codec)
3661 struct ad198x_spec *spec;
3664 err = alloc_ad_spec(codec);
3669 spec->gen.mixer_nid = 0x20;
3670 spec->gen.mixer_merge_nid = 0x21;
3671 spec->gen.beep_nid = 0x10;
3672 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3674 snd_hda_pick_fixup(codec, NULL, ad1884_fixup_tbl, ad1884_fixups);
3675 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3677 err = ad198x_parse_auto_config(codec);
3680 err = ad1983_add_spdif_mux_ctl(codec);
3684 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3689 snd_hda_gen_free(codec);
3693 #ifdef ENABLE_AD_STATIC_QUIRKS
3694 static int patch_ad1884_basic(struct hda_codec *codec)
3696 struct ad198x_spec *spec;
3699 err = alloc_ad_spec(codec);
3704 err = snd_hda_attach_beep_device(codec, 0x10);
3709 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3711 spec->multiout.max_channels = 2;
3712 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3713 spec->multiout.dac_nids = ad1884_dac_nids;
3714 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3715 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3716 spec->adc_nids = ad1884_adc_nids;
3717 spec->capsrc_nids = ad1884_capsrc_nids;
3718 spec->input_mux = &ad1884_capture_source;
3719 spec->num_mixers = 1;
3720 spec->mixers[0] = ad1884_base_mixers;
3721 spec->num_init_verbs = 1;
3722 spec->init_verbs[0] = ad1884_init_verbs;
3723 spec->spdif_route = 0;
3725 spec->loopback.amplist = ad1884_loopbacks;
3727 spec->vmaster_nid = 0x04;
3728 /* we need to cover all playback volumes */
3729 spec->slave_vols = ad1884_slave_vols;
3730 /* slaves may contain input volumes, so we can't raise to 0dB blindly */
3731 spec->avoid_init_slave_vol = 1;
3733 codec->patch_ops = ad198x_patch_ops;
3735 codec->no_trigger_sense = 1;
3736 codec->no_sticky_stream = 1;
3741 static int patch_ad1884(struct hda_codec *codec)
3745 board_config = snd_hda_check_board_config(codec, AD1884_MODELS,
3746 ad1884_models, NULL);
3747 if (board_config < 0) {
3748 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3750 board_config = AD1884_AUTO;
3753 if (board_config == AD1884_AUTO)
3754 return ad1884_parse_auto_config(codec);
3756 return patch_ad1884_basic(codec);
3758 #else /* ENABLE_AD_STATIC_QUIRKS */
3759 #define patch_ad1884 ad1884_parse_auto_config
3760 #endif /* ENABLE_AD_STATIC_QUIRKS */
3763 #ifdef ENABLE_AD_STATIC_QUIRKS
3765 * Lenovo Thinkpad T61/X61
3767 static const struct hda_input_mux ad1984_thinkpad_capture_source = {
3771 { "Internal Mic", 0x1 },
3773 { "Dock Mic", 0x4 },
3779 * Dell Precision T3400
3781 static const struct hda_input_mux ad1984_dell_desktop_capture_source = {
3784 { "Front Mic", 0x0 },
3791 static const struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3792 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3793 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3794 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3795 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3796 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3797 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3798 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3799 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3800 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3801 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3802 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3803 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3804 HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
3805 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
3806 HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
3807 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3808 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3809 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3810 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3812 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3813 /* The multiple "Capture Source" controls confuse alsamixer
3814 * So call somewhat different..
3816 /* .name = "Capture Source", */
3817 .name = "Input Source",
3819 .info = ad198x_mux_enum_info,
3820 .get = ad198x_mux_enum_get,
3821 .put = ad198x_mux_enum_put,
3823 /* SPDIF controls */
3824 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3826 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3827 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3828 /* identical with ad1983 */
3829 .info = ad1983_spdif_route_info,
3830 .get = ad1983_spdif_route_get,
3831 .put = ad1983_spdif_route_put,
3836 /* additional verbs */
3837 static const struct hda_verb ad1984_thinkpad_init_verbs[] = {
3838 /* Port-E (docking station mic) pin */
3839 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3840 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3841 /* docking mic boost */
3842 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3843 /* Analog PC Beeper - allow firmware/ACPI beeps */
3844 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3) | 0x1a},
3845 /* Analog mixer - docking mic; mute as default */
3846 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3847 /* enable EAPD bit */
3848 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3853 * Dell Precision T3400
3855 static const struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3856 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3857 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3858 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3859 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3860 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3861 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3862 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3863 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3864 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3865 HDA_CODEC_VOLUME("Line-In Boost Volume", 0x15, 0x0, HDA_INPUT),
3866 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
3867 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3868 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3869 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3870 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3872 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3873 /* The multiple "Capture Source" controls confuse alsamixer
3874 * So call somewhat different..
3876 /* .name = "Capture Source", */
3877 .name = "Input Source",
3879 .info = ad198x_mux_enum_info,
3880 .get = ad198x_mux_enum_get,
3881 .put = ad198x_mux_enum_put,
3886 /* Digial MIC ADC NID 0x05 + 0x06 */
3887 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3888 struct hda_codec *codec,
3889 unsigned int stream_tag,
3890 unsigned int format,
3891 struct snd_pcm_substream *substream)
3893 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3894 stream_tag, 0, format);
3898 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3899 struct hda_codec *codec,
3900 struct snd_pcm_substream *substream)
3902 snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number);
3906 static const struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3912 .prepare = ad1984_pcm_dmic_prepare,
3913 .cleanup = ad1984_pcm_dmic_cleanup
3917 static int ad1984_build_pcms(struct hda_codec *codec)
3919 struct ad198x_spec *spec = codec->spec;
3920 struct hda_pcm *info;
3923 err = ad198x_build_pcms(codec);
3927 info = spec->pcm_rec + codec->num_pcms;
3929 info->name = "AD1984 Digital Mic";
3930 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3939 AD1984_DELL_DESKTOP,
3943 static const char * const ad1984_models[AD1984_MODELS] = {
3944 [AD1984_AUTO] = "auto",
3945 [AD1984_BASIC] = "basic",
3946 [AD1984_THINKPAD] = "thinkpad",
3947 [AD1984_DELL_DESKTOP] = "dell_desktop",
3950 static const struct snd_pci_quirk ad1984_cfg_tbl[] = {
3951 /* Lenovo Thinkpad T61/X61 */
3952 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD),
3953 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3954 SND_PCI_QUIRK(0x1028, 0x0233, "Dell Latitude E6400", AD1984_DELL_DESKTOP),
3958 static int patch_ad1984(struct hda_codec *codec)
3960 struct ad198x_spec *spec;
3961 int board_config, err;
3963 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3964 ad1984_models, ad1984_cfg_tbl);
3965 if (board_config < 0) {
3966 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3968 board_config = AD1984_AUTO;
3971 if (board_config == AD1984_AUTO)
3972 return ad1884_parse_auto_config(codec);
3974 err = patch_ad1884_basic(codec);
3979 switch (board_config) {
3981 /* additional digital mics */
3982 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3983 codec->patch_ops.build_pcms = ad1984_build_pcms;
3985 case AD1984_THINKPAD:
3986 if (codec->subsystem_id == 0x17aa20fb) {
3987 /* Thinpad X300 does not have the ability to do SPDIF,
3988 or attach to docking station to use SPDIF */
3989 spec->multiout.dig_out_nid = 0;
3991 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3992 spec->input_mux = &ad1984_thinkpad_capture_source;
3993 spec->mixers[0] = ad1984_thinkpad_mixers;
3994 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3995 spec->analog_beep = 1;
3997 case AD1984_DELL_DESKTOP:
3998 spec->multiout.dig_out_nid = 0;
3999 spec->input_mux = &ad1984_dell_desktop_capture_source;
4000 spec->mixers[0] = ad1984_dell_desktop_mixers;
4005 #else /* ENABLE_AD_STATIC_QUIRKS */
4006 #define patch_ad1984 ad1884_parse_auto_config
4007 #endif /* ENABLE_AD_STATIC_QUIRKS */
4011 * AD1883 / AD1884A / AD1984A / AD1984B
4013 * port-B (0x14) - front mic-in
4014 * port-E (0x1c) - rear mic-in
4015 * port-F (0x16) - CD / ext out
4016 * port-C (0x15) - rear line-in
4017 * port-D (0x12) - rear line-out
4018 * port-A (0x11) - front hp-out
4020 * AD1984A = AD1884A + digital-mic
4021 * AD1883 = equivalent with AD1984A
4022 * AD1984B = AD1984A + extra SPDIF-out
4025 * We share the single DAC for both HP and line-outs (see AD1884/1984).
4028 #ifdef ENABLE_AD_STATIC_QUIRKS
4029 static const hda_nid_t ad1884a_dac_nids[1] = {
4033 #define ad1884a_adc_nids ad1884_adc_nids
4034 #define ad1884a_capsrc_nids ad1884_capsrc_nids
4036 #define AD1884A_SPDIF_OUT 0x02
4038 static const struct hda_input_mux ad1884a_capture_source = {
4041 { "Front Mic", 0x0 },
4049 static const struct snd_kcontrol_new ad1884a_base_mixers[] = {
4050 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4051 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
4052 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
4053 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4054 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
4055 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
4056 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4057 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4058 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4059 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4060 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
4061 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4062 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4063 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4064 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
4065 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
4066 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
4067 HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x0, HDA_INPUT),
4068 HDA_CODEC_VOLUME("Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
4069 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4070 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4071 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
4072 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
4074 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4075 /* The multiple "Capture Source" controls confuse alsamixer
4076 * So call somewhat different..
4078 /* .name = "Capture Source", */
4079 .name = "Input Source",
4081 .info = ad198x_mux_enum_info,
4082 .get = ad198x_mux_enum_get,
4083 .put = ad198x_mux_enum_put,
4085 /* SPDIF controls */
4086 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
4088 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4089 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4090 /* identical with ad1983 */
4091 .info = ad1983_spdif_route_info,
4092 .get = ad1983_spdif_route_get,
4093 .put = ad1983_spdif_route_put,
4099 * initialization verbs
4101 static const struct hda_verb ad1884a_init_verbs[] = {
4102 /* DACs; unmute as default */
4103 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4104 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4105 /* Port-A (HP) mixer - route only from analog mixer */
4106 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4107 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4109 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4110 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4111 /* Port-D (Line-out) mixer - route only from analog mixer */
4112 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4113 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4115 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4116 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4117 /* Mono-out mixer - route only from analog mixer */
4118 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4119 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4121 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4122 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4123 /* Port-B (front mic) pin */
4124 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4125 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4126 /* Port-C (rear line-in) pin */
4127 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4128 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4129 /* Port-E (rear mic) pin */
4130 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4131 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4132 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
4133 /* Port-F (CD) pin */
4134 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4135 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4136 /* Analog mixer; mute as default */
4137 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4138 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4139 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4140 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4141 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
4142 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4143 /* Analog Mix output amp */
4144 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4145 /* capture sources */
4146 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
4147 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4148 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4149 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4150 /* SPDIF output amp */
4151 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4156 static const struct hda_amp_list ad1884a_loopbacks[] = {
4157 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4158 { 0x20, HDA_INPUT, 1 }, /* Mic */
4159 { 0x20, HDA_INPUT, 2 }, /* CD */
4160 { 0x20, HDA_INPUT, 4 }, /* Docking */
4168 * Port A: Headphone jack
4170 * Port C: Internal MIC
4171 * Port D: Dock Line Out (if enabled)
4172 * Port E: Dock Line In (if enabled)
4173 * Port F: Internal speakers
4176 static int ad1884a_mobile_master_sw_put(struct snd_kcontrol *kcontrol,
4177 struct snd_ctl_elem_value *ucontrol)
4179 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4180 int ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
4181 int mute = (!ucontrol->value.integer.value[0] &&
4182 !ucontrol->value.integer.value[1]);
4183 /* toggle GPIO1 according to the mute state */
4184 snd_hda_codec_write_cache(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
4189 static const struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
4190 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4192 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4193 .name = "Master Playback Switch",
4194 .subdevice = HDA_SUBDEV_AMP_FLAG,
4195 .info = snd_hda_mixer_amp_switch_info,
4196 .get = snd_hda_mixer_amp_switch_get,
4197 .put = ad1884a_mobile_master_sw_put,
4198 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4200 HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4201 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4202 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4203 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4204 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4205 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4206 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4207 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4208 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4209 HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
4210 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
4211 HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
4212 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4213 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4217 static const struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
4218 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4219 /*HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
4221 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4222 .name = "Master Playback Switch",
4223 .subdevice = HDA_SUBDEV_AMP_FLAG,
4224 .info = snd_hda_mixer_amp_switch_info,
4225 .get = snd_hda_mixer_amp_switch_get,
4226 .put = ad1884a_mobile_master_sw_put,
4227 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4229 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4230 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4231 HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
4232 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
4233 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4234 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4238 /* mute internal speaker if HP is plugged */
4239 static void ad1884a_hp_automute(struct hda_codec *codec)
4241 unsigned int present;
4243 present = snd_hda_jack_detect(codec, 0x11);
4244 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
4245 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4246 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
4247 present ? 0x00 : 0x02);
4250 /* switch to external mic if plugged */
4251 static void ad1884a_hp_automic(struct hda_codec *codec)
4253 unsigned int present;
4255 present = snd_hda_jack_detect(codec, 0x14);
4256 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
4260 #define AD1884A_HP_EVENT 0x37
4261 #define AD1884A_MIC_EVENT 0x36
4263 /* unsolicited event for HP jack sensing */
4264 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4266 switch (res >> 26) {
4267 case AD1884A_HP_EVENT:
4268 ad1884a_hp_automute(codec);
4270 case AD1884A_MIC_EVENT:
4271 ad1884a_hp_automic(codec);
4276 /* initialize jack-sensing, too */
4277 static int ad1884a_hp_init(struct hda_codec *codec)
4280 ad1884a_hp_automute(codec);
4281 ad1884a_hp_automic(codec);
4285 /* mute internal speaker if HP or docking HP is plugged */
4286 static void ad1884a_laptop_automute(struct hda_codec *codec)
4288 unsigned int present;
4290 present = snd_hda_jack_detect(codec, 0x11);
4292 present = snd_hda_jack_detect(codec, 0x12);
4293 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
4294 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4295 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
4296 present ? 0x00 : 0x02);
4299 /* switch to external mic if plugged */
4300 static void ad1884a_laptop_automic(struct hda_codec *codec)
4304 if (snd_hda_jack_detect(codec, 0x14))
4306 else if (snd_hda_jack_detect(codec, 0x1c))
4310 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, idx);
4313 /* unsolicited event for HP jack sensing */
4314 static void ad1884a_laptop_unsol_event(struct hda_codec *codec,
4317 switch (res >> 26) {
4318 case AD1884A_HP_EVENT:
4319 ad1884a_laptop_automute(codec);
4321 case AD1884A_MIC_EVENT:
4322 ad1884a_laptop_automic(codec);
4327 /* initialize jack-sensing, too */
4328 static int ad1884a_laptop_init(struct hda_codec *codec)
4331 ad1884a_laptop_automute(codec);
4332 ad1884a_laptop_automic(codec);
4336 /* additional verbs for laptop model */
4337 static const struct hda_verb ad1884a_laptop_verbs[] = {
4338 /* Port-A (HP) pin - always unmuted */
4339 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4340 /* Port-F (int speaker) mixer - route only from analog mixer */
4341 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4342 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4343 /* Port-F (int speaker) pin */
4344 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4345 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4346 /* required for compaq 6530s/6531s speaker output */
4347 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4348 /* Port-C pin - internal mic-in */
4349 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4350 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4351 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4352 /* Port-D (docking line-out) pin - default unmuted */
4353 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4355 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4356 /* unsolicited event for pin-sense */
4357 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4358 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4359 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4360 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4361 /* allow to touch GPIO1 (for mute control) */
4362 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4363 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4364 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4368 static const struct hda_verb ad1884a_mobile_verbs[] = {
4369 /* DACs; unmute as default */
4370 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4371 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4372 /* Port-A (HP) mixer - route only from analog mixer */
4373 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4374 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4376 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4377 /* Port-A (HP) pin - always unmuted */
4378 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4379 /* Port-B (mic jack) pin */
4380 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4381 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4382 /* Port-C (int mic) pin */
4383 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4384 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4385 /* Port-F (int speaker) mixer - route only from analog mixer */
4386 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4387 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4389 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4390 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4391 /* Analog mixer; mute as default */
4392 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4393 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4394 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4395 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4396 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4397 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4398 /* Analog Mix output amp */
4399 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4400 /* capture sources */
4401 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4402 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4403 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4404 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4405 /* unsolicited event for pin-sense */
4406 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4407 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4408 /* allow to touch GPIO1 (for mute control) */
4409 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4410 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4411 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4420 * 0x17 - built-in mic
4423 static const struct hda_verb ad1984a_thinkpad_verbs[] = {
4425 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4427 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4429 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4430 /* unsolicited event for pin-sense */
4431 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4432 /* internal mic - dmic */
4433 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4434 /* set magic COEFs for dmic */
4435 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4436 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4440 static const struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
4441 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4442 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
4443 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4444 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4445 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4446 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4447 HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
4448 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x17, 0x0, HDA_INPUT),
4449 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4450 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4452 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4453 .name = "Capture Source",
4454 .info = ad198x_mux_enum_info,
4455 .get = ad198x_mux_enum_get,
4456 .put = ad198x_mux_enum_put,
4461 static const struct hda_input_mux ad1984a_thinkpad_capture_source = {
4465 { "Internal Mic", 0x5 },
4470 /* mute internal speaker if HP is plugged */
4471 static void ad1984a_thinkpad_automute(struct hda_codec *codec)
4473 unsigned int present;
4475 present = snd_hda_jack_detect(codec, 0x11);
4476 snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
4477 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4480 /* unsolicited event for HP jack sensing */
4481 static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec,
4484 if ((res >> 26) != AD1884A_HP_EVENT)
4486 ad1984a_thinkpad_automute(codec);
4489 /* initialize jack-sensing, too */
4490 static int ad1984a_thinkpad_init(struct hda_codec *codec)
4493 ad1984a_thinkpad_automute(codec);
4499 * 0x12 - HP/line-out
4500 * 0x13 - speaker (mono)
4504 static const struct hda_verb ad1984a_precision_verbs[] = {
4505 /* Unmute main output path */
4506 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4507 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE + 0x1f}, /* 0dB */
4508 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) + 0x17}, /* 0dB */
4509 /* Analog mixer; mute as default */
4510 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4511 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4512 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4513 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4514 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4515 /* Select mic as input */
4516 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
4517 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE + 0x27}, /* 0dB */
4518 /* Configure as mic */
4519 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4520 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4522 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4524 {0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4525 /* unsolicited event for pin-sense */
4526 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4530 static const struct snd_kcontrol_new ad1984a_precision_mixers[] = {
4531 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4532 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
4533 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4534 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4535 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4536 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4537 HDA_CODEC_VOLUME("Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
4538 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4539 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x13, 0x0, HDA_OUTPUT),
4540 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4541 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4546 /* mute internal speaker if HP is plugged */
4547 static void ad1984a_precision_automute(struct hda_codec *codec)
4549 unsigned int present;
4551 present = snd_hda_jack_detect(codec, 0x12);
4552 snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0,
4553 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4557 /* unsolicited event for HP jack sensing */
4558 static void ad1984a_precision_unsol_event(struct hda_codec *codec,
4561 if ((res >> 26) != AD1884A_HP_EVENT)
4563 ad1984a_precision_automute(codec);
4566 /* initialize jack-sensing, too */
4567 static int ad1984a_precision_init(struct hda_codec *codec)
4570 ad1984a_precision_automute(codec);
4577 * port-A (0x11) - front hp-out
4578 * port-B (0x14) - unused
4579 * port-C (0x15) - unused
4580 * port-D (0x12) - rear line out
4581 * port-E (0x1c) - front mic-in
4582 * port-F (0x16) - Internal speakers
4583 * digital-mic (0x17) - Internal mic
4586 static const struct hda_verb ad1984a_touchsmart_verbs[] = {
4587 /* DACs; unmute as default */
4588 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4589 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4590 /* Port-A (HP) mixer - route only from analog mixer */
4591 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4592 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4594 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4595 /* Port-A (HP) pin - always unmuted */
4596 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4597 /* Port-E (int speaker) mixer - route only from analog mixer */
4598 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, 0x03},
4600 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4601 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4602 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4603 /* Port-F (int speaker) mixer - route only from analog mixer */
4604 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4605 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4607 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4608 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4609 /* Analog mixer; mute as default */
4610 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4611 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4612 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4613 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4614 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4615 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4616 /* Analog Mix output amp */
4617 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4618 /* capture sources */
4619 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4620 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4621 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4622 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4623 /* unsolicited event for pin-sense */
4624 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4625 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4626 /* allow to touch GPIO1 (for mute control) */
4627 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4628 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4629 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4630 /* internal mic - dmic */
4631 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4632 /* set magic COEFs for dmic */
4633 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4634 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4638 static const struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = {
4639 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4640 /* HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
4642 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4643 .subdevice = HDA_SUBDEV_AMP_FLAG,
4644 .name = "Master Playback Switch",
4645 .info = snd_hda_mixer_amp_switch_info,
4646 .get = snd_hda_mixer_amp_switch_get,
4647 .put = ad1884a_mobile_master_sw_put,
4648 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4650 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4651 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4652 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4653 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4654 HDA_CODEC_VOLUME("Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
4655 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x17, 0x0, HDA_INPUT),
4659 /* switch to external mic if plugged */
4660 static void ad1984a_touchsmart_automic(struct hda_codec *codec)
4662 if (snd_hda_jack_detect(codec, 0x1c))
4663 snd_hda_codec_write(codec, 0x0c, 0,
4664 AC_VERB_SET_CONNECT_SEL, 0x4);
4666 snd_hda_codec_write(codec, 0x0c, 0,
4667 AC_VERB_SET_CONNECT_SEL, 0x5);
4671 /* unsolicited event for HP jack sensing */
4672 static void ad1984a_touchsmart_unsol_event(struct hda_codec *codec,
4675 switch (res >> 26) {
4676 case AD1884A_HP_EVENT:
4677 ad1884a_hp_automute(codec);
4679 case AD1884A_MIC_EVENT:
4680 ad1984a_touchsmart_automic(codec);
4685 /* initialize jack-sensing, too */
4686 static int ad1984a_touchsmart_init(struct hda_codec *codec)
4689 ad1884a_hp_automute(codec);
4690 ad1984a_touchsmart_automic(codec);
4709 static const char * const ad1884a_models[AD1884A_MODELS] = {
4710 [AD1884A_AUTO] = "auto",
4711 [AD1884A_DESKTOP] = "desktop",
4712 [AD1884A_LAPTOP] = "laptop",
4713 [AD1884A_MOBILE] = "mobile",
4714 [AD1884A_THINKPAD] = "thinkpad",
4715 [AD1984A_TOUCHSMART] = "touchsmart",
4716 [AD1984A_PRECISION] = "precision",
4719 static const struct snd_pci_quirk ad1884a_cfg_tbl[] = {
4720 SND_PCI_QUIRK(0x1028, 0x04ac, "Precision R5500", AD1984A_PRECISION),
4721 SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
4722 SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
4723 SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
4724 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE),
4725 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30d0, "HP laptop", AD1884A_LAPTOP),
4726 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP),
4727 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP),
4728 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x7010, "HP laptop", AD1884A_MOBILE),
4729 SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
4730 SND_PCI_QUIRK(0x103c, 0x2a82, "Touchsmart", AD1984A_TOUCHSMART),
4734 static int patch_ad1884a(struct hda_codec *codec)
4736 struct ad198x_spec *spec;
4737 int err, board_config;
4739 board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
4742 if (board_config < 0) {
4743 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4745 board_config = AD1884A_AUTO;
4748 if (board_config == AD1884A_AUTO)
4749 return ad1884_parse_auto_config(codec);
4751 err = alloc_ad_spec(codec);
4756 err = snd_hda_attach_beep_device(codec, 0x10);
4761 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4763 spec->multiout.max_channels = 2;
4764 spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
4765 spec->multiout.dac_nids = ad1884a_dac_nids;
4766 spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
4767 spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
4768 spec->adc_nids = ad1884a_adc_nids;
4769 spec->capsrc_nids = ad1884a_capsrc_nids;
4770 spec->input_mux = &ad1884a_capture_source;
4771 spec->num_mixers = 1;
4772 spec->mixers[0] = ad1884a_base_mixers;
4773 spec->num_init_verbs = 1;
4774 spec->init_verbs[0] = ad1884a_init_verbs;
4775 spec->spdif_route = 0;
4777 spec->loopback.amplist = ad1884a_loopbacks;
4779 codec->patch_ops = ad198x_patch_ops;
4781 /* override some parameters */
4782 switch (board_config) {
4783 case AD1884A_LAPTOP:
4784 spec->mixers[0] = ad1884a_laptop_mixers;
4785 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
4786 spec->multiout.dig_out_nid = 0;
4787 codec->patch_ops.unsol_event = ad1884a_laptop_unsol_event;
4788 codec->patch_ops.init = ad1884a_laptop_init;
4789 /* set the upper-limit for mixer amp to 0dB for avoiding the
4790 * possible damage by overloading
4792 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4793 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4794 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4795 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4796 (1 << AC_AMPCAP_MUTE_SHIFT));
4798 case AD1884A_MOBILE:
4799 spec->mixers[0] = ad1884a_mobile_mixers;
4800 spec->init_verbs[0] = ad1884a_mobile_verbs;
4801 spec->multiout.dig_out_nid = 0;
4802 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
4803 codec->patch_ops.init = ad1884a_hp_init;
4804 /* set the upper-limit for mixer amp to 0dB for avoiding the
4805 * possible damage by overloading
4807 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4808 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4809 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4810 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4811 (1 << AC_AMPCAP_MUTE_SHIFT));
4813 case AD1884A_THINKPAD:
4814 spec->mixers[0] = ad1984a_thinkpad_mixers;
4815 spec->init_verbs[spec->num_init_verbs++] =
4816 ad1984a_thinkpad_verbs;
4817 spec->multiout.dig_out_nid = 0;
4818 spec->input_mux = &ad1984a_thinkpad_capture_source;
4819 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
4820 codec->patch_ops.init = ad1984a_thinkpad_init;
4822 case AD1984A_PRECISION:
4823 spec->mixers[0] = ad1984a_precision_mixers;
4824 spec->init_verbs[spec->num_init_verbs++] =
4825 ad1984a_precision_verbs;
4826 spec->multiout.dig_out_nid = 0;
4827 codec->patch_ops.unsol_event = ad1984a_precision_unsol_event;
4828 codec->patch_ops.init = ad1984a_precision_init;
4830 case AD1984A_TOUCHSMART:
4831 spec->mixers[0] = ad1984a_touchsmart_mixers;
4832 spec->init_verbs[0] = ad1984a_touchsmart_verbs;
4833 spec->multiout.dig_out_nid = 0;
4834 codec->patch_ops.unsol_event = ad1984a_touchsmart_unsol_event;
4835 codec->patch_ops.init = ad1984a_touchsmart_init;
4836 /* set the upper-limit for mixer amp to 0dB for avoiding the
4837 * possible damage by overloading
4839 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4840 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4841 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4842 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4843 (1 << AC_AMPCAP_MUTE_SHIFT));
4847 codec->no_trigger_sense = 1;
4848 codec->no_sticky_stream = 1;
4852 #else /* ENABLE_AD_STATIC_QUIRKS */
4853 #define patch_ad1884a ad1884_parse_auto_config
4854 #endif /* ENABLE_AD_STATIC_QUIRKS */
4860 * port-A - front hp-out
4861 * port-B - front mic-in
4862 * port-C - rear line-in, shared surr-out (3stack)
4863 * port-D - rear line-out
4864 * port-E - rear mic-in, shared clfe-out (3stack)
4865 * port-F - rear surr-out (6stack)
4866 * port-G - rear clfe-out (6stack)
4869 #ifdef ENABLE_AD_STATIC_QUIRKS
4870 static const hda_nid_t ad1882_dac_nids[3] = {
4874 static const hda_nid_t ad1882_adc_nids[2] = {
4878 static const hda_nid_t ad1882_capsrc_nids[2] = {
4882 #define AD1882_SPDIF_OUT 0x02
4884 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
4885 static const struct hda_input_mux ad1882_capture_source = {
4888 { "Front Mic", 0x1 },
4896 /* list: 0x11, 0x39, 0x3a, 0x3c, 0x18, 0x1f, 0x12, 0x20 */
4897 static const struct hda_input_mux ad1882a_capture_source = {
4900 { "Front Mic", 0x1 },
4903 { "Digital Mic", 0x06 },
4908 static const struct snd_kcontrol_new ad1882_base_mixers[] = {
4909 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
4910 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
4911 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
4912 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
4913 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
4914 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4915 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
4916 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
4918 HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
4919 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
4920 HDA_CODEC_VOLUME("Line-In Boost Volume", 0x3a, 0x0, HDA_OUTPUT),
4921 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4922 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4923 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
4924 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
4926 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4927 /* The multiple "Capture Source" controls confuse alsamixer
4928 * So call somewhat different..
4930 /* .name = "Capture Source", */
4931 .name = "Input Source",
4933 .info = ad198x_mux_enum_info,
4934 .get = ad198x_mux_enum_get,
4935 .put = ad198x_mux_enum_put,
4937 /* SPDIF controls */
4938 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
4940 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4941 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4942 /* identical with ad1983 */
4943 .info = ad1983_spdif_route_info,
4944 .get = ad1983_spdif_route_get,
4945 .put = ad1983_spdif_route_put,
4950 static const struct snd_kcontrol_new ad1882_loopback_mixers[] = {
4951 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4952 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4953 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4954 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4955 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
4956 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
4957 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4958 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4962 static const struct snd_kcontrol_new ad1882a_loopback_mixers[] = {
4963 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4964 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4965 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4966 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4967 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
4968 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4969 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4970 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4971 HDA_CODEC_VOLUME("Digital Mic Boost Volume", 0x1f, 0x0, HDA_INPUT),
4975 static const struct snd_kcontrol_new ad1882_3stack_mixers[] = {
4976 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4977 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
4978 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
4980 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4981 .name = "Channel Mode",
4982 .info = ad198x_ch_mode_info,
4983 .get = ad198x_ch_mode_get,
4984 .put = ad198x_ch_mode_put,
4989 /* simple auto-mute control for AD1882 3-stack board */
4990 #define AD1882_HP_EVENT 0x01
4992 static void ad1882_3stack_automute(struct hda_codec *codec)
4994 bool mute = snd_hda_jack_detect(codec, 0x11);
4995 snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4996 mute ? 0 : PIN_OUT);
4999 static int ad1882_3stack_automute_init(struct hda_codec *codec)
5002 ad1882_3stack_automute(codec);
5006 static void ad1882_3stack_unsol_event(struct hda_codec *codec, unsigned int res)
5008 switch (res >> 26) {
5009 case AD1882_HP_EVENT:
5010 ad1882_3stack_automute(codec);
5015 static const struct snd_kcontrol_new ad1882_6stack_mixers[] = {
5016 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5017 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
5018 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
5022 static const struct hda_verb ad1882_ch2_init[] = {
5023 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5024 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5025 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5026 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5027 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5028 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5032 static const struct hda_verb ad1882_ch4_init[] = {
5033 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5034 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5035 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5036 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5037 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5038 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5042 static const struct hda_verb ad1882_ch6_init[] = {
5043 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5044 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5045 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5046 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5047 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5048 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5052 static const struct hda_channel_mode ad1882_modes[3] = {
5053 { 2, ad1882_ch2_init },
5054 { 4, ad1882_ch4_init },
5055 { 6, ad1882_ch6_init },
5059 * initialization verbs
5061 static const struct hda_verb ad1882_init_verbs[] = {
5062 /* DACs; mute as default */
5063 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5064 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5065 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5066 /* Port-A (HP) mixer */
5067 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5068 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5070 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5071 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5072 /* HP selector - select DAC2 */
5073 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
5074 /* Port-D (Line-out) mixer */
5075 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5076 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5078 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5079 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5080 /* Mono-out mixer */
5081 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5082 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5084 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5085 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5086 /* Port-B (front mic) pin */
5087 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5088 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5089 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
5090 /* Port-C (line-in) pin */
5091 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5092 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5093 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
5094 /* Port-C mixer - mute as input */
5095 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5096 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5097 /* Port-E (mic-in) pin */
5098 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5099 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5100 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
5101 /* Port-E mixer - mute as input */
5102 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5103 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5104 /* Port-F (surround) */
5105 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5106 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5108 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5109 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5110 /* Analog mixer; mute as default */
5111 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
5112 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5113 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5114 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5115 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5116 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5117 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
5118 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
5119 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
5120 /* Analog Mix output amp */
5121 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
5122 /* SPDIF output selector */
5123 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
5124 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
5125 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
5129 static const struct hda_verb ad1882_3stack_automute_verbs[] = {
5130 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1882_HP_EVENT},
5135 static const struct hda_amp_list ad1882_loopbacks[] = {
5136 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
5137 { 0x20, HDA_INPUT, 1 }, /* Mic */
5138 { 0x20, HDA_INPUT, 4 }, /* Line */
5139 { 0x20, HDA_INPUT, 6 }, /* CD */
5149 AD1882_3STACK_AUTOMUTE,
5153 static const char * const ad1882_models[AD1986A_MODELS] = {
5154 [AD1882_AUTO] = "auto",
5155 [AD1882_3STACK] = "3stack",
5156 [AD1882_6STACK] = "6stack",
5157 [AD1882_3STACK_AUTOMUTE] = "3stack-automute",
5159 #endif /* ENABLE_AD_STATIC_QUIRKS */
5161 static int ad1882_parse_auto_config(struct hda_codec *codec)
5163 struct ad198x_spec *spec;
5166 err = alloc_ad_spec(codec);
5171 spec->gen.mixer_nid = 0x20;
5172 spec->gen.mixer_merge_nid = 0x21;
5173 spec->gen.beep_nid = 0x10;
5174 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
5175 err = ad198x_parse_auto_config(codec);
5178 err = ad1988_add_spdif_mux_ctl(codec);
5184 snd_hda_gen_free(codec);
5188 #ifdef ENABLE_AD_STATIC_QUIRKS
5189 static int patch_ad1882(struct hda_codec *codec)
5191 struct ad198x_spec *spec;
5192 int err, board_config;
5194 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
5195 ad1882_models, NULL);
5196 if (board_config < 0) {
5197 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5199 board_config = AD1882_AUTO;
5202 if (board_config == AD1882_AUTO)
5203 return ad1882_parse_auto_config(codec);
5205 err = alloc_ad_spec(codec);
5210 err = snd_hda_attach_beep_device(codec, 0x10);
5215 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
5217 spec->multiout.max_channels = 6;
5218 spec->multiout.num_dacs = 3;
5219 spec->multiout.dac_nids = ad1882_dac_nids;
5220 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
5221 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
5222 spec->adc_nids = ad1882_adc_nids;
5223 spec->capsrc_nids = ad1882_capsrc_nids;
5224 if (codec->vendor_id == 0x11d41882)
5225 spec->input_mux = &ad1882_capture_source;
5227 spec->input_mux = &ad1882a_capture_source;
5228 spec->num_mixers = 2;
5229 spec->mixers[0] = ad1882_base_mixers;
5230 if (codec->vendor_id == 0x11d41882)
5231 spec->mixers[1] = ad1882_loopback_mixers;
5233 spec->mixers[1] = ad1882a_loopback_mixers;
5234 spec->num_init_verbs = 1;
5235 spec->init_verbs[0] = ad1882_init_verbs;
5236 spec->spdif_route = 0;
5238 spec->loopback.amplist = ad1882_loopbacks;
5240 spec->vmaster_nid = 0x04;
5242 codec->patch_ops = ad198x_patch_ops;
5244 /* override some parameters */
5245 switch (board_config) {
5248 case AD1882_3STACK_AUTOMUTE:
5249 spec->num_mixers = 3;
5250 spec->mixers[2] = ad1882_3stack_mixers;
5251 spec->channel_mode = ad1882_modes;
5252 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
5253 spec->need_dac_fix = 1;
5254 spec->multiout.max_channels = 2;
5255 spec->multiout.num_dacs = 1;
5256 if (board_config != AD1882_3STACK) {
5257 spec->init_verbs[spec->num_init_verbs++] =
5258 ad1882_3stack_automute_verbs;
5259 codec->patch_ops.unsol_event = ad1882_3stack_unsol_event;
5260 codec->patch_ops.init = ad1882_3stack_automute_init;
5264 spec->num_mixers = 3;
5265 spec->mixers[2] = ad1882_6stack_mixers;
5269 codec->no_trigger_sense = 1;
5270 codec->no_sticky_stream = 1;
5274 #else /* ENABLE_AD_STATIC_QUIRKS */
5275 #define patch_ad1882 ad1882_parse_auto_config
5276 #endif /* ENABLE_AD_STATIC_QUIRKS */
5282 static const struct hda_codec_preset snd_hda_preset_analog[] = {
5283 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
5284 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
5285 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
5286 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
5287 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
5288 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
5289 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
5290 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
5291 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
5292 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
5293 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
5294 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
5295 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 },
5296 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },
5297 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },
5301 MODULE_ALIAS("snd-hda-codec-id:11d4*");
5303 MODULE_LICENSE("GPL");
5304 MODULE_DESCRIPTION("Analog Devices HD-audio codec");
5306 static struct hda_codec_preset_list analog_list = {
5307 .preset = snd_hda_preset_analog,
5308 .owner = THIS_MODULE,
5311 static int __init patch_analog_init(void)
5313 return snd_hda_add_codec_preset(&analog_list);
5316 static void __exit patch_analog_exit(void)
5318 snd_hda_delete_codec_preset(&analog_list);
5321 module_init(patch_analog_init)
5322 module_exit(patch_analog_exit)