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/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include "hda_local.h"
33 struct snd_kcontrol_new *mixers[5];
35 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
36 const struct hda_verb *init_verbs[5]; /* initialization verbs
37 * don't forget NULL termination!
39 unsigned int num_init_verbs;
42 struct hda_multi_out multiout; /* playback set-up
43 * max_channels, dacs must be set
44 * dig_out_nid and hp_nid are optional
46 unsigned int cur_eapd;
47 unsigned int need_dac_fix;
50 unsigned int num_adc_nids;
52 hda_nid_t dig_in_nid; /* digital-in NID; optional */
55 const struct hda_input_mux *input_mux;
56 hda_nid_t *capsrc_nids;
57 unsigned int cur_mux[3];
60 const struct hda_channel_mode *channel_mode;
64 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
66 unsigned int spdif_route;
68 /* dynamic controls, init_verbs and input_mux */
69 struct auto_pin_cfg autocfg;
70 struct snd_array kctls;
71 struct hda_input_mux private_imux;
72 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
74 unsigned int jack_present :1;
75 unsigned int inv_jack_detect:1; /* inverted jack-detection */
76 unsigned int inv_eapd:1; /* inverted EAPD implementation */
78 #ifdef CONFIG_SND_HDA_POWER_SAVE
79 struct hda_loopback_check loopback;
81 /* for virtual master */
82 hda_nid_t vmaster_nid;
83 const char **slave_vols;
84 const char **slave_sws;
88 * input MUX handling (common part)
90 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
92 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
93 struct ad198x_spec *spec = codec->spec;
95 return snd_hda_input_mux_info(spec->input_mux, uinfo);
98 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
100 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
101 struct ad198x_spec *spec = codec->spec;
102 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
104 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
108 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
110 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
111 struct ad198x_spec *spec = codec->spec;
112 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
114 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
115 spec->capsrc_nids[adc_idx],
116 &spec->cur_mux[adc_idx]);
120 * initialization (common callbacks)
122 static int ad198x_init(struct hda_codec *codec)
124 struct ad198x_spec *spec = codec->spec;
127 for (i = 0; i < spec->num_init_verbs; i++)
128 snd_hda_sequence_write(codec, spec->init_verbs[i]);
132 static const char *ad_slave_vols[] = {
133 "Front Playback Volume",
134 "Surround Playback Volume",
135 "Center Playback Volume",
136 "LFE Playback Volume",
137 "Side Playback Volume",
138 "Headphone Playback Volume",
139 "Mono Playback Volume",
140 "Speaker Playback Volume",
141 "IEC958 Playback Volume",
145 static const char *ad_slave_sws[] = {
146 "Front Playback Switch",
147 "Surround Playback Switch",
148 "Center Playback Switch",
149 "LFE Playback Switch",
150 "Side Playback Switch",
151 "Headphone Playback Switch",
152 "Mono Playback Switch",
153 "Speaker Playback Switch",
154 "IEC958 Playback Switch",
158 static void ad198x_free_kctls(struct hda_codec *codec);
160 #ifdef CONFIG_SND_HDA_INPUT_BEEP
161 /* additional beep mixers; the actual parameters are overwritten at build */
162 static struct snd_kcontrol_new ad_beep_mixer[] = {
163 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),
164 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT),
168 #define set_beep_amp(spec, nid, idx, dir) \
169 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */
171 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
174 static int ad198x_build_controls(struct hda_codec *codec)
176 struct ad198x_spec *spec = codec->spec;
177 struct snd_kcontrol *kctl;
181 for (i = 0; i < spec->num_mixers; i++) {
182 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
186 if (spec->multiout.dig_out_nid) {
187 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
190 err = snd_hda_create_spdif_share_sw(codec,
194 spec->multiout.share_spdif = 1;
196 if (spec->dig_in_nid) {
197 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
202 /* create beep controls if needed */
203 #ifdef CONFIG_SND_HDA_INPUT_BEEP
204 if (spec->beep_amp) {
205 struct snd_kcontrol_new *knew;
206 for (knew = ad_beep_mixer; knew->name; knew++) {
207 struct snd_kcontrol *kctl;
208 kctl = snd_ctl_new1(knew, codec);
211 kctl->private_value = spec->beep_amp;
212 err = snd_hda_ctl_add(codec, 0, kctl);
219 /* if we have no master control, let's create it */
220 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
221 unsigned int vmaster_tlv[4];
222 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
223 HDA_OUTPUT, vmaster_tlv);
224 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
227 spec->slave_vols : ad_slave_vols));
231 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
232 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
235 spec->slave_sws : ad_slave_sws));
240 ad198x_free_kctls(codec); /* no longer needed */
242 /* assign Capture Source enums to NID */
243 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
245 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
246 for (i = 0; kctl && i < kctl->count; i++) {
247 err = snd_hda_add_nid(codec, kctl, i, spec->capsrc_nids[i]);
252 /* assign IEC958 enums to NID */
253 kctl = snd_hda_find_mixer_ctl(codec,
254 SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source");
256 err = snd_hda_add_nid(codec, kctl, 0,
257 spec->multiout.dig_out_nid);
265 #ifdef CONFIG_SND_HDA_POWER_SAVE
266 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
268 struct ad198x_spec *spec = codec->spec;
269 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
274 * Analog playback callbacks
276 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
277 struct hda_codec *codec,
278 struct snd_pcm_substream *substream)
280 struct ad198x_spec *spec = codec->spec;
281 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
285 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
286 struct hda_codec *codec,
287 unsigned int stream_tag,
289 struct snd_pcm_substream *substream)
291 struct ad198x_spec *spec = codec->spec;
292 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
296 static int ad198x_playback_pcm_cleanup(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_cleanup(codec, &spec->multiout);
307 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
308 struct hda_codec *codec,
309 struct snd_pcm_substream *substream)
311 struct ad198x_spec *spec = codec->spec;
312 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
315 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
316 struct hda_codec *codec,
317 struct snd_pcm_substream *substream)
319 struct ad198x_spec *spec = codec->spec;
320 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
323 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
324 struct hda_codec *codec,
325 unsigned int stream_tag,
327 struct snd_pcm_substream *substream)
329 struct ad198x_spec *spec = codec->spec;
330 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
334 static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
335 struct hda_codec *codec,
336 struct snd_pcm_substream *substream)
338 struct ad198x_spec *spec = codec->spec;
339 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
345 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
346 struct hda_codec *codec,
347 unsigned int stream_tag,
349 struct snd_pcm_substream *substream)
351 struct ad198x_spec *spec = codec->spec;
352 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
353 stream_tag, 0, format);
357 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
358 struct hda_codec *codec,
359 struct snd_pcm_substream *substream)
361 struct ad198x_spec *spec = codec->spec;
362 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
369 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
372 .channels_max = 6, /* changed later */
373 .nid = 0, /* fill later */
375 .open = ad198x_playback_pcm_open,
376 .prepare = ad198x_playback_pcm_prepare,
377 .cleanup = ad198x_playback_pcm_cleanup
381 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
385 .nid = 0, /* fill later */
387 .prepare = ad198x_capture_pcm_prepare,
388 .cleanup = ad198x_capture_pcm_cleanup
392 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
396 .nid = 0, /* fill later */
398 .open = ad198x_dig_playback_pcm_open,
399 .close = ad198x_dig_playback_pcm_close,
400 .prepare = ad198x_dig_playback_pcm_prepare,
401 .cleanup = ad198x_dig_playback_pcm_cleanup
405 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
409 /* NID is set in alc_build_pcms */
412 static int ad198x_build_pcms(struct hda_codec *codec)
414 struct ad198x_spec *spec = codec->spec;
415 struct hda_pcm *info = spec->pcm_rec;
418 codec->pcm_info = info;
420 info->name = "AD198x Analog";
421 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
422 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
423 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
424 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
425 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
426 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
428 if (spec->multiout.dig_out_nid) {
431 info->name = "AD198x Digital";
432 info->pcm_type = HDA_PCM_TYPE_SPDIF;
433 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
434 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
435 if (spec->dig_in_nid) {
436 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
437 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
444 static inline void ad198x_shutup(struct hda_codec *codec)
446 snd_hda_shutup_pins(codec);
449 static void ad198x_free_kctls(struct hda_codec *codec)
451 struct ad198x_spec *spec = codec->spec;
453 if (spec->kctls.list) {
454 struct snd_kcontrol_new *kctl = spec->kctls.list;
456 for (i = 0; i < spec->kctls.used; i++)
459 snd_array_free(&spec->kctls);
462 static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
465 struct ad198x_spec *spec = codec->spec;
466 snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE,
467 !spec->inv_eapd ? 0x00 : 0x02);
468 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE,
469 !spec->inv_eapd ? 0x00 : 0x02);
472 static void ad198x_power_eapd(struct hda_codec *codec)
474 /* We currently only handle front, HP */
475 switch (codec->vendor_id) {
484 ad198x_power_eapd_write(codec, 0x12, 0x11);
488 ad198x_power_eapd_write(codec, 0x05, 0x06);
491 ad198x_power_eapd_write(codec, 0x1b, 0x1a);
497 ad198x_power_eapd_write(codec, 0x29, 0x22);
502 static void ad198x_free(struct hda_codec *codec)
504 struct ad198x_spec *spec = codec->spec;
509 ad198x_shutup(codec);
510 ad198x_free_kctls(codec);
512 snd_hda_detach_beep_device(codec);
515 #ifdef SND_HDA_NEEDS_RESUME
516 static int ad198x_suspend(struct hda_codec *codec, pm_message_t state)
518 ad198x_shutup(codec);
519 ad198x_power_eapd(codec);
523 static int ad198x_resume(struct hda_codec *codec)
526 snd_hda_codec_resume_amp(codec);
527 snd_hda_codec_resume_cache(codec);
532 static struct hda_codec_ops ad198x_patch_ops = {
533 .build_controls = ad198x_build_controls,
534 .build_pcms = ad198x_build_pcms,
537 #ifdef CONFIG_SND_HDA_POWER_SAVE
538 .check_power_status = ad198x_check_power_status,
540 #ifdef SND_HDA_NEEDS_RESUME
541 .suspend = ad198x_suspend,
542 .resume = ad198x_resume,
544 .reboot_notify = ad198x_shutup,
550 * the private value = nid
552 #define ad198x_eapd_info snd_ctl_boolean_mono_info
554 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
555 struct snd_ctl_elem_value *ucontrol)
557 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
558 struct ad198x_spec *spec = codec->spec;
560 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
562 ucontrol->value.integer.value[0] = spec->cur_eapd;
566 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
567 struct snd_ctl_elem_value *ucontrol)
569 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
570 struct ad198x_spec *spec = codec->spec;
571 hda_nid_t nid = kcontrol->private_value & 0xff;
573 eapd = !!ucontrol->value.integer.value[0];
576 if (eapd == spec->cur_eapd)
578 spec->cur_eapd = eapd;
579 snd_hda_codec_write_cache(codec, nid,
580 0, AC_VERB_SET_EAPD_BTLENABLE,
585 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
586 struct snd_ctl_elem_info *uinfo);
587 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
588 struct snd_ctl_elem_value *ucontrol);
589 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
590 struct snd_ctl_elem_value *ucontrol);
597 #define AD1986A_SPDIF_OUT 0x02
598 #define AD1986A_FRONT_DAC 0x03
599 #define AD1986A_SURR_DAC 0x04
600 #define AD1986A_CLFE_DAC 0x05
601 #define AD1986A_ADC 0x06
603 static hda_nid_t ad1986a_dac_nids[3] = {
604 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
606 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
607 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
609 static struct hda_input_mux ad1986a_capture_source = {
623 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
624 .ops = &snd_hda_bind_vol,
626 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
627 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
628 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
633 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
634 .ops = &snd_hda_bind_sw,
636 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
637 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
638 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
646 static struct snd_kcontrol_new ad1986a_mixers[] = {
648 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
650 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
651 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
652 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
653 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
654 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
655 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
656 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
657 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
658 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
659 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
660 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
661 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
662 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
663 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
664 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
665 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
666 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
667 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
668 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
669 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
670 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
671 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
672 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
673 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
674 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
676 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
677 .name = "Capture Source",
678 .info = ad198x_mux_enum_info,
679 .get = ad198x_mux_enum_get,
680 .put = ad198x_mux_enum_put,
682 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
686 /* additional mixers for 3stack mode */
687 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
690 .name = "Channel Mode",
691 .info = ad198x_ch_mode_info,
692 .get = ad198x_ch_mode_get,
693 .put = ad198x_ch_mode_put,
698 /* laptop model - 2ch only */
699 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
701 /* master controls both pins 0x1a and 0x1b */
702 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
703 .ops = &snd_hda_bind_vol,
705 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
706 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
711 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
712 .ops = &snd_hda_bind_sw,
714 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
715 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
720 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
721 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
722 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
723 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
724 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
725 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
726 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
727 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
728 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
729 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
730 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
731 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
732 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
733 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
735 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
736 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
737 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
738 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
740 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
741 .name = "Capture Source",
742 .info = ad198x_mux_enum_info,
743 .get = ad198x_mux_enum_get,
744 .put = ad198x_mux_enum_put,
749 /* laptop-eapd model - 2ch only */
751 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
755 { "Internal Mic", 0x4 },
760 static struct hda_input_mux ad1986a_automic_capture_source = {
768 static struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = {
769 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
770 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
774 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
775 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
776 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
777 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
778 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
779 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
780 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
781 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
783 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
784 .name = "Capture Source",
785 .info = ad198x_mux_enum_info,
786 .get = ad198x_mux_enum_get,
787 .put = ad198x_mux_enum_put,
790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
791 .name = "External Amplifier",
792 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
793 .info = ad198x_eapd_info,
794 .get = ad198x_eapd_get,
795 .put = ad198x_eapd_put,
796 .private_value = 0x1b, /* port-D */
801 static struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {
802 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
803 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
807 /* re-connect the mic boost input according to the jack sensing */
808 static void ad1986a_automic(struct hda_codec *codec)
810 unsigned int present;
811 present = snd_hda_jack_detect(codec, 0x1f);
812 /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
813 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
817 #define AD1986A_MIC_EVENT 0x36
819 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
822 if ((res >> 26) != AD1986A_MIC_EVENT)
824 ad1986a_automic(codec);
827 static int ad1986a_automic_init(struct hda_codec *codec)
830 ad1986a_automic(codec);
834 /* laptop-automute - 2ch only */
836 static void ad1986a_update_hp(struct hda_codec *codec)
838 struct ad198x_spec *spec = codec->spec;
841 if (spec->jack_present)
842 mute = HDA_AMP_MUTE; /* mute internal speaker */
844 /* unmute internal speaker if necessary */
845 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
846 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
850 static void ad1986a_hp_automute(struct hda_codec *codec)
852 struct ad198x_spec *spec = codec->spec;
854 spec->jack_present = snd_hda_jack_detect(codec, 0x1a);
855 if (spec->inv_jack_detect)
856 spec->jack_present = !spec->jack_present;
857 ad1986a_update_hp(codec);
860 #define AD1986A_HP_EVENT 0x37
862 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
864 if ((res >> 26) != AD1986A_HP_EVENT)
866 ad1986a_hp_automute(codec);
869 static int ad1986a_hp_init(struct hda_codec *codec)
872 ad1986a_hp_automute(codec);
876 /* bind hp and internal speaker mute (with plug check) */
877 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
878 struct snd_ctl_elem_value *ucontrol)
880 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
881 long *valp = ucontrol->value.integer.value;
884 change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
886 valp[0] ? 0 : HDA_AMP_MUTE);
887 change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
889 valp[1] ? 0 : HDA_AMP_MUTE);
891 ad1986a_update_hp(codec);
895 static struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {
896 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
898 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
899 .name = "Master Playback Switch",
900 .subdevice = HDA_SUBDEV_AMP_FLAG,
901 .info = snd_hda_mixer_amp_switch_info,
902 .get = snd_hda_mixer_amp_switch_get,
903 .put = ad1986a_hp_master_sw_put,
904 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
911 * initialization verbs
913 static struct hda_verb ad1986a_init_verbs[] = {
914 /* Front, Surround, CLFE DAC; mute as default */
915 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
916 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
917 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
919 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
920 /* HP, Line-Out, Surround, CLFE selectors */
921 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
922 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
923 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
924 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
926 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
927 /* Mic selector: Mic 1/2 pin */
928 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
929 /* Line-in selector: Line-in */
930 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
932 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
933 /* Record selector: mic */
934 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
935 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
936 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
937 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
938 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
939 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
940 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
942 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
943 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
944 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
945 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
946 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
947 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
948 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
950 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
951 /* Front, Surround, CLFE Pins */
952 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
953 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
954 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
956 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
958 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
959 /* Line, Aux, CD, Beep-In Pin */
960 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
961 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
962 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
963 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
964 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
968 static struct hda_verb ad1986a_ch2_init[] = {
969 /* Surround out -> Line In */
970 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
971 /* Line-in selectors */
972 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
974 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
975 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
976 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
980 static struct hda_verb ad1986a_ch4_init[] = {
981 /* Surround out -> Surround */
982 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
983 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
985 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
986 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
990 static struct hda_verb ad1986a_ch6_init[] = {
991 /* Surround out -> Surround out */
992 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
993 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
995 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
996 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
1000 static struct hda_channel_mode ad1986a_modes[3] = {
1001 { 2, ad1986a_ch2_init },
1002 { 4, ad1986a_ch4_init },
1003 { 6, ad1986a_ch6_init },
1006 /* eapd initialization */
1007 static struct hda_verb ad1986a_eapd_init_verbs[] = {
1008 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
1012 static struct hda_verb ad1986a_automic_verbs[] = {
1013 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1014 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1015 /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
1016 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
1017 {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
1021 /* Ultra initialization */
1022 static struct hda_verb ad1986a_ultra_init[] = {
1023 /* eapd initialization */
1024 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
1025 /* CLFE -> Mic in */
1026 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
1027 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1028 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
1032 /* pin sensing on HP jack */
1033 static struct hda_verb ad1986a_hp_init_verbs[] = {
1034 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
1038 static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec,
1041 switch (res >> 26) {
1042 case AD1986A_HP_EVENT:
1043 ad1986a_hp_automute(codec);
1045 case AD1986A_MIC_EVENT:
1046 ad1986a_automic(codec);
1051 static int ad1986a_samsung_p50_init(struct hda_codec *codec)
1054 ad1986a_hp_automute(codec);
1055 ad1986a_automic(codec);
1065 AD1986A_LAPTOP_EAPD,
1066 AD1986A_LAPTOP_AUTOMUTE,
1069 AD1986A_SAMSUNG_P50,
1073 static const char *ad1986a_models[AD1986A_MODELS] = {
1074 [AD1986A_6STACK] = "6stack",
1075 [AD1986A_3STACK] = "3stack",
1076 [AD1986A_LAPTOP] = "laptop",
1077 [AD1986A_LAPTOP_EAPD] = "laptop-eapd",
1078 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
1079 [AD1986A_ULTRA] = "ultra",
1080 [AD1986A_SAMSUNG] = "samsung",
1081 [AD1986A_SAMSUNG_P50] = "samsung-p50",
1084 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
1085 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
1086 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
1087 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
1088 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
1089 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
1090 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
1091 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
1092 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
1093 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
1094 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
1095 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
1096 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
1097 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
1098 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
1099 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
1100 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
1101 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40-10Q", AD1986A_3STACK),
1102 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
1103 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
1104 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50),
1105 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
1106 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),
1107 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
1108 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
1109 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
1110 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
1111 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
1115 #ifdef CONFIG_SND_HDA_POWER_SAVE
1116 static struct hda_amp_list ad1986a_loopbacks[] = {
1117 { 0x13, HDA_OUTPUT, 0 }, /* Mic */
1118 { 0x14, HDA_OUTPUT, 0 }, /* Phone */
1119 { 0x15, HDA_OUTPUT, 0 }, /* CD */
1120 { 0x16, HDA_OUTPUT, 0 }, /* Aux */
1121 { 0x17, HDA_OUTPUT, 0 }, /* Line */
1126 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
1128 unsigned int conf = snd_hda_codec_get_pincfg(codec, nid);
1129 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
1132 static int patch_ad1986a(struct hda_codec *codec)
1134 struct ad198x_spec *spec;
1135 int err, board_config;
1137 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1143 err = snd_hda_attach_beep_device(codec, 0x19);
1148 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
1150 spec->multiout.max_channels = 6;
1151 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
1152 spec->multiout.dac_nids = ad1986a_dac_nids;
1153 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
1154 spec->num_adc_nids = 1;
1155 spec->adc_nids = ad1986a_adc_nids;
1156 spec->capsrc_nids = ad1986a_capsrc_nids;
1157 spec->input_mux = &ad1986a_capture_source;
1158 spec->num_mixers = 1;
1159 spec->mixers[0] = ad1986a_mixers;
1160 spec->num_init_verbs = 1;
1161 spec->init_verbs[0] = ad1986a_init_verbs;
1162 #ifdef CONFIG_SND_HDA_POWER_SAVE
1163 spec->loopback.amplist = ad1986a_loopbacks;
1165 spec->vmaster_nid = 0x1b;
1166 spec->inv_eapd = 1; /* AD1986A has the inverted EAPD implementation */
1168 codec->patch_ops = ad198x_patch_ops;
1170 /* override some parameters */
1171 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1174 switch (board_config) {
1175 case AD1986A_3STACK:
1176 spec->num_mixers = 2;
1177 spec->mixers[1] = ad1986a_3st_mixers;
1178 spec->num_init_verbs = 2;
1179 spec->init_verbs[1] = ad1986a_ch2_init;
1180 spec->channel_mode = ad1986a_modes;
1181 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1182 spec->need_dac_fix = 1;
1183 spec->multiout.max_channels = 2;
1184 spec->multiout.num_dacs = 1;
1186 case AD1986A_LAPTOP:
1187 spec->mixers[0] = ad1986a_laptop_mixers;
1188 spec->multiout.max_channels = 2;
1189 spec->multiout.num_dacs = 1;
1190 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1192 case AD1986A_LAPTOP_EAPD:
1193 spec->num_mixers = 3;
1194 spec->mixers[0] = ad1986a_laptop_master_mixers;
1195 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1196 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1197 spec->num_init_verbs = 2;
1198 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1199 spec->multiout.max_channels = 2;
1200 spec->multiout.num_dacs = 1;
1201 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1202 if (!is_jack_available(codec, 0x25))
1203 spec->multiout.dig_out_nid = 0;
1204 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1206 case AD1986A_SAMSUNG:
1207 spec->num_mixers = 2;
1208 spec->mixers[0] = ad1986a_laptop_master_mixers;
1209 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1210 spec->num_init_verbs = 3;
1211 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1212 spec->init_verbs[2] = ad1986a_automic_verbs;
1213 spec->multiout.max_channels = 2;
1214 spec->multiout.num_dacs = 1;
1215 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1216 if (!is_jack_available(codec, 0x25))
1217 spec->multiout.dig_out_nid = 0;
1218 spec->input_mux = &ad1986a_automic_capture_source;
1219 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1220 codec->patch_ops.init = ad1986a_automic_init;
1222 case AD1986A_SAMSUNG_P50:
1223 spec->num_mixers = 2;
1224 spec->mixers[0] = ad1986a_automute_master_mixers;
1225 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1226 spec->num_init_verbs = 4;
1227 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1228 spec->init_verbs[2] = ad1986a_automic_verbs;
1229 spec->init_verbs[3] = ad1986a_hp_init_verbs;
1230 spec->multiout.max_channels = 2;
1231 spec->multiout.num_dacs = 1;
1232 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1233 if (!is_jack_available(codec, 0x25))
1234 spec->multiout.dig_out_nid = 0;
1235 spec->input_mux = &ad1986a_automic_capture_source;
1236 codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event;
1237 codec->patch_ops.init = ad1986a_samsung_p50_init;
1239 case AD1986A_LAPTOP_AUTOMUTE:
1240 spec->num_mixers = 3;
1241 spec->mixers[0] = ad1986a_automute_master_mixers;
1242 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1243 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1244 spec->num_init_verbs = 3;
1245 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1246 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1247 spec->multiout.max_channels = 2;
1248 spec->multiout.num_dacs = 1;
1249 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1250 if (!is_jack_available(codec, 0x25))
1251 spec->multiout.dig_out_nid = 0;
1252 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1253 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1254 codec->patch_ops.init = ad1986a_hp_init;
1255 /* Lenovo N100 seems to report the reversed bit
1256 * for HP jack-sensing
1258 spec->inv_jack_detect = 1;
1261 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1262 spec->num_init_verbs = 2;
1263 spec->init_verbs[1] = ad1986a_ultra_init;
1264 spec->multiout.max_channels = 2;
1265 spec->multiout.num_dacs = 1;
1266 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1267 spec->multiout.dig_out_nid = 0;
1271 /* AD1986A has a hardware problem that it can't share a stream
1272 * with multiple output pins. The copy of front to surrounds
1273 * causes noisy or silent outputs at a certain timing, e.g.
1274 * changing the volume.
1275 * So, let's disable the shared stream.
1277 spec->multiout.no_share_stream = 1;
1279 codec->no_trigger_sense = 1;
1288 #define AD1983_SPDIF_OUT 0x02
1289 #define AD1983_DAC 0x03
1290 #define AD1983_ADC 0x04
1292 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1293 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1294 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1296 static struct hda_input_mux ad1983_capture_source = {
1302 { "Mix Mono", 0x3 },
1307 * SPDIF playback route
1309 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1311 static char *texts[] = { "PCM", "ADC" };
1313 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1315 uinfo->value.enumerated.items = 2;
1316 if (uinfo->value.enumerated.item > 1)
1317 uinfo->value.enumerated.item = 1;
1318 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1322 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1324 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1325 struct ad198x_spec *spec = codec->spec;
1327 ucontrol->value.enumerated.item[0] = spec->spdif_route;
1331 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1333 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1334 struct ad198x_spec *spec = codec->spec;
1336 if (ucontrol->value.enumerated.item[0] > 1)
1338 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1339 spec->spdif_route = ucontrol->value.enumerated.item[0];
1340 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1341 AC_VERB_SET_CONNECT_SEL,
1348 static struct snd_kcontrol_new ad1983_mixers[] = {
1349 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1350 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1351 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1352 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1353 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1354 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1355 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1356 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1357 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1358 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1359 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1360 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1361 HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1362 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1363 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1365 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1366 .name = "Capture Source",
1367 .info = ad198x_mux_enum_info,
1368 .get = ad198x_mux_enum_get,
1369 .put = ad198x_mux_enum_put,
1372 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1373 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1374 .info = ad1983_spdif_route_info,
1375 .get = ad1983_spdif_route_get,
1376 .put = ad1983_spdif_route_put,
1381 static struct hda_verb ad1983_init_verbs[] = {
1382 /* Front, HP, Mono; mute as default */
1383 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1384 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1385 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1386 /* Beep, PCM, Mic, Line-In: mute */
1387 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1388 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1389 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1390 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1391 /* Front, HP selectors; from Mix */
1392 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1393 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1394 /* Mono selector; from Mix */
1395 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1396 /* Mic selector; Mic */
1397 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1398 /* Line-in selector: Line-in */
1399 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1400 /* Mic boost: 0dB */
1401 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1402 /* Record selector: mic */
1403 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1404 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1405 /* SPDIF route: PCM */
1406 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1408 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1410 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1412 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1414 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1416 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1420 #ifdef CONFIG_SND_HDA_POWER_SAVE
1421 static struct hda_amp_list ad1983_loopbacks[] = {
1422 { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1423 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1428 static int patch_ad1983(struct hda_codec *codec)
1430 struct ad198x_spec *spec;
1433 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1439 err = snd_hda_attach_beep_device(codec, 0x10);
1444 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1446 spec->multiout.max_channels = 2;
1447 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1448 spec->multiout.dac_nids = ad1983_dac_nids;
1449 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1450 spec->num_adc_nids = 1;
1451 spec->adc_nids = ad1983_adc_nids;
1452 spec->capsrc_nids = ad1983_capsrc_nids;
1453 spec->input_mux = &ad1983_capture_source;
1454 spec->num_mixers = 1;
1455 spec->mixers[0] = ad1983_mixers;
1456 spec->num_init_verbs = 1;
1457 spec->init_verbs[0] = ad1983_init_verbs;
1458 spec->spdif_route = 0;
1459 #ifdef CONFIG_SND_HDA_POWER_SAVE
1460 spec->loopback.amplist = ad1983_loopbacks;
1462 spec->vmaster_nid = 0x05;
1464 codec->patch_ops = ad198x_patch_ops;
1466 codec->no_trigger_sense = 1;
1473 * AD1981 HD specific
1476 #define AD1981_SPDIF_OUT 0x02
1477 #define AD1981_DAC 0x03
1478 #define AD1981_ADC 0x04
1480 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1481 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1482 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1484 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1485 static struct hda_input_mux ad1981_capture_source = {
1488 { "Front Mic", 0x0 },
1491 { "Mix Mono", 0x3 },
1498 static struct snd_kcontrol_new ad1981_mixers[] = {
1499 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1500 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1501 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1502 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1503 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1504 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1505 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1506 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1507 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1508 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1509 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1510 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1511 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1512 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1513 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1514 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1515 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1516 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1517 HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1518 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
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,
1528 /* identical with AD1983 */
1530 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1531 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1532 .info = ad1983_spdif_route_info,
1533 .get = ad1983_spdif_route_get,
1534 .put = ad1983_spdif_route_put,
1539 static struct hda_verb ad1981_init_verbs[] = {
1540 /* Front, HP, Mono; mute as default */
1541 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1542 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1543 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1544 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1545 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1546 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1547 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1548 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1549 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1550 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1551 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1552 /* Front, HP selectors; from Mix */
1553 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1554 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1555 /* Mono selector; from Mix */
1556 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1557 /* Mic Mixer; select Front Mic */
1558 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1559 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1560 /* Mic boost: 0dB */
1561 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1562 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1563 /* Record selector: Front mic */
1564 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1565 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1566 /* SPDIF route: PCM */
1567 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1569 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1571 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1573 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1574 /* Front & Rear Mic Pins */
1575 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1576 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1578 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1580 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1581 /* Line-Out as Input: disabled */
1582 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1586 #ifdef CONFIG_SND_HDA_POWER_SAVE
1587 static struct hda_amp_list ad1981_loopbacks[] = {
1588 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1589 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1590 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1591 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1592 { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1598 * Patch for HP nx6320
1600 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1601 * speaker output enabled _and_ mute-LED off.
1604 #define AD1981_HP_EVENT 0x37
1605 #define AD1981_MIC_EVENT 0x38
1607 static struct hda_verb ad1981_hp_init_verbs[] = {
1608 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1609 /* pin sensing on HP and Mic jacks */
1610 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1611 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1615 /* turn on/off EAPD (+ mute HP) as a master switch */
1616 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1617 struct snd_ctl_elem_value *ucontrol)
1619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1620 struct ad198x_spec *spec = codec->spec;
1622 if (! ad198x_eapd_put(kcontrol, ucontrol))
1624 /* change speaker pin appropriately */
1625 snd_hda_codec_write(codec, 0x05, 0,
1626 AC_VERB_SET_PIN_WIDGET_CONTROL,
1627 spec->cur_eapd ? PIN_OUT : 0);
1628 /* toggle HP mute appropriately */
1629 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1631 spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1635 /* bind volumes of both NID 0x05 and 0x06 */
1636 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1637 .ops = &snd_hda_bind_vol,
1639 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1640 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1645 /* mute internal speaker if HP is plugged */
1646 static void ad1981_hp_automute(struct hda_codec *codec)
1648 unsigned int present;
1650 present = snd_hda_jack_detect(codec, 0x06);
1651 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1652 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1655 /* toggle input of built-in and mic jack appropriately */
1656 static void ad1981_hp_automic(struct hda_codec *codec)
1658 static struct hda_verb mic_jack_on[] = {
1659 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1660 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1663 static struct hda_verb mic_jack_off[] = {
1664 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1665 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1668 unsigned int present;
1670 present = snd_hda_jack_detect(codec, 0x08);
1672 snd_hda_sequence_write(codec, mic_jack_on);
1674 snd_hda_sequence_write(codec, mic_jack_off);
1677 /* unsolicited event for HP jack sensing */
1678 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1683 case AD1981_HP_EVENT:
1684 ad1981_hp_automute(codec);
1686 case AD1981_MIC_EVENT:
1687 ad1981_hp_automic(codec);
1692 static struct hda_input_mux ad1981_hp_capture_source = {
1696 { "Docking-Station", 0x1 },
1701 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1702 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1704 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1705 .subdevice = HDA_SUBDEV_NID_FLAG | 0x05,
1706 .name = "Master Playback Switch",
1707 .info = ad198x_eapd_info,
1708 .get = ad198x_eapd_get,
1709 .put = ad1981_hp_master_sw_put,
1710 .private_value = 0x05,
1712 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1713 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1715 /* FIXME: analog mic/line loopback doesn't work with my tests...
1716 * (although recording is OK)
1718 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1719 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1720 HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1721 HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1722 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1723 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1724 /* FIXME: does this laptop have analog CD connection? */
1725 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1726 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1728 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1729 HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1730 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1731 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1733 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1734 .name = "Capture Source",
1735 .info = ad198x_mux_enum_info,
1736 .get = ad198x_mux_enum_get,
1737 .put = ad198x_mux_enum_put,
1742 /* initialize jack-sensing, too */
1743 static int ad1981_hp_init(struct hda_codec *codec)
1746 ad1981_hp_automute(codec);
1747 ad1981_hp_automic(codec);
1751 /* configuration for Toshiba Laptops */
1752 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1753 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1754 /* pin sensing on HP and Mic jacks */
1755 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1756 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1760 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1761 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1762 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1766 /* configuration for Lenovo Thinkpad T60 */
1767 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1768 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1769 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1770 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1771 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1772 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1773 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1774 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1775 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1776 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1777 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1778 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1780 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1781 .name = "Capture Source",
1782 .info = ad198x_mux_enum_info,
1783 .get = ad198x_mux_enum_get,
1784 .put = ad198x_mux_enum_put,
1786 /* identical with AD1983 */
1788 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1789 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1790 .info = ad1983_spdif_route_info,
1791 .get = ad1983_spdif_route_get,
1792 .put = ad1983_spdif_route_put,
1797 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1815 static const char *ad1981_models[AD1981_MODELS] = {
1817 [AD1981_THINKPAD] = "thinkpad",
1818 [AD1981_BASIC] = "basic",
1819 [AD1981_TOSHIBA] = "toshiba"
1822 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1823 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1824 SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
1826 SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP),
1827 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1828 /* Lenovo Thinkpad T60/X60/Z6xx */
1829 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD),
1830 /* HP nx6320 (reversed SSID, H/W bug) */
1831 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1835 static int patch_ad1981(struct hda_codec *codec)
1837 struct ad198x_spec *spec;
1838 int err, board_config;
1840 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1846 err = snd_hda_attach_beep_device(codec, 0x10);
1851 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
1853 spec->multiout.max_channels = 2;
1854 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1855 spec->multiout.dac_nids = ad1981_dac_nids;
1856 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1857 spec->num_adc_nids = 1;
1858 spec->adc_nids = ad1981_adc_nids;
1859 spec->capsrc_nids = ad1981_capsrc_nids;
1860 spec->input_mux = &ad1981_capture_source;
1861 spec->num_mixers = 1;
1862 spec->mixers[0] = ad1981_mixers;
1863 spec->num_init_verbs = 1;
1864 spec->init_verbs[0] = ad1981_init_verbs;
1865 spec->spdif_route = 0;
1866 #ifdef CONFIG_SND_HDA_POWER_SAVE
1867 spec->loopback.amplist = ad1981_loopbacks;
1869 spec->vmaster_nid = 0x05;
1871 codec->patch_ops = ad198x_patch_ops;
1873 /* override some parameters */
1874 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1877 switch (board_config) {
1879 spec->mixers[0] = ad1981_hp_mixers;
1880 spec->num_init_verbs = 2;
1881 spec->init_verbs[1] = ad1981_hp_init_verbs;
1882 spec->multiout.dig_out_nid = 0;
1883 spec->input_mux = &ad1981_hp_capture_source;
1885 codec->patch_ops.init = ad1981_hp_init;
1886 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1887 /* set the upper-limit for mixer amp to 0dB for avoiding the
1888 * possible damage by overloading
1890 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
1891 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
1892 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
1893 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
1894 (1 << AC_AMPCAP_MUTE_SHIFT));
1896 case AD1981_THINKPAD:
1897 spec->mixers[0] = ad1981_thinkpad_mixers;
1898 spec->input_mux = &ad1981_thinkpad_capture_source;
1899 /* set the upper-limit for mixer amp to 0dB for avoiding the
1900 * possible damage by overloading
1902 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
1903 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
1904 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
1905 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
1906 (1 << AC_AMPCAP_MUTE_SHIFT));
1908 case AD1981_TOSHIBA:
1909 spec->mixers[0] = ad1981_hp_mixers;
1910 spec->mixers[1] = ad1981_toshiba_mixers;
1911 spec->num_init_verbs = 2;
1912 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1913 spec->multiout.dig_out_nid = 0;
1914 spec->input_mux = &ad1981_hp_capture_source;
1915 codec->patch_ops.init = ad1981_hp_init;
1916 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1920 codec->no_trigger_sense = 1;
1929 * Output pins and routes
1931 * Pin Mix Sel DAC (*)
1932 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1933 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1934 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
1935 * port-D 0x12 (mute/hp) <- 0x29 <- 04
1936 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1937 * port-F 0x16 (mute) <- 0x2a <- 06
1938 * port-G 0x24 (mute) <- 0x27 <- 05
1939 * port-H 0x25 (mute) <- 0x28 <- 0a
1940 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1942 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1943 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1945 * Input pins and routes
1947 * pin boost mix input # / adc input #
1948 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1949 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1950 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1951 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1952 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1953 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1954 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1955 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1959 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1960 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1962 * Inputs of Analog Mix (0x20)
1963 * 0:Port-B (front mic)
1964 * 1:Port-C/G/H (line-in)
1966 * 3:Port-D (line-in/2)
1967 * 4:Port-E/G/H (mic-in)
1968 * 5:Port-F (mic2-in)
1974 * 1:Port-B (front mic-in)
1975 * 2:Port-C (line-in)
1976 * 3:Port-F (mic2-in)
1981 * 8:Port-D (line-in/2)
1984 * Proposed pin assignments by the datasheet
1987 * Port-A front headphone
1997 * Port-A front headphone
1999 * C rear line-in/surround
2001 * E rear mic-in/CLFE
2007 * D internal speaker (with EAPD)
2008 * E/F quad mic array
2024 /* reivision id to check workarounds */
2025 #define AD1988A_REV2 0x100200
2027 #define is_rev2(codec) \
2028 ((codec)->vendor_id == 0x11d41988 && \
2029 (codec)->revision_id == AD1988A_REV2)
2035 static hda_nid_t ad1988_6stack_dac_nids[4] = {
2036 0x04, 0x06, 0x05, 0x0a
2039 static hda_nid_t ad1988_3stack_dac_nids[3] = {
2043 /* for AD1988A revision-2, DAC2-4 are swapped */
2044 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
2045 0x04, 0x05, 0x0a, 0x06
2048 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
2052 static hda_nid_t ad1988_adc_nids[3] = {
2056 static hda_nid_t ad1988_capsrc_nids[3] = {
2060 #define AD1988_SPDIF_OUT 0x02
2061 #define AD1988_SPDIF_OUT_HDMI 0x0b
2062 #define AD1988_SPDIF_IN 0x07
2064 static hda_nid_t ad1989b_slave_dig_outs[] = {
2065 AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
2068 static struct hda_input_mux ad1988_6stack_capture_source = {
2071 { "Front Mic", 0x1 }, /* port-B */
2072 { "Line", 0x2 }, /* port-C */
2073 { "Mic", 0x4 }, /* port-E */
2079 static struct hda_input_mux ad1988_laptop_capture_source = {
2082 { "Mic/Line", 0x1 }, /* port-B */
2090 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
2091 struct snd_ctl_elem_info *uinfo)
2093 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2094 struct ad198x_spec *spec = codec->spec;
2095 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
2096 spec->num_channel_mode);
2099 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
2100 struct snd_ctl_elem_value *ucontrol)
2102 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2103 struct ad198x_spec *spec = codec->spec;
2104 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
2105 spec->num_channel_mode, spec->multiout.max_channels);
2108 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
2109 struct snd_ctl_elem_value *ucontrol)
2111 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2112 struct ad198x_spec *spec = codec->spec;
2113 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
2114 spec->num_channel_mode,
2115 &spec->multiout.max_channels);
2116 if (err >= 0 && spec->need_dac_fix)
2117 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2122 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
2123 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2124 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2125 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2126 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2127 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2131 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
2132 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2133 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2134 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2135 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
2136 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2140 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
2141 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2142 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
2143 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
2144 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
2145 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
2146 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2147 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2149 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2150 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2151 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2152 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2153 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2154 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2155 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2156 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2158 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2159 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2161 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2162 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2168 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
2169 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2170 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2171 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2172 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2176 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
2177 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2178 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2179 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
2180 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
2184 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
2185 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2186 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
2187 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
2188 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
2189 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2190 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2192 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2193 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2194 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2195 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2196 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2197 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2198 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2199 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2201 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2202 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2204 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2205 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2207 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2208 .name = "Channel Mode",
2209 .info = ad198x_ch_mode_info,
2210 .get = ad198x_ch_mode_get,
2211 .put = ad198x_ch_mode_put,
2218 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
2219 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2220 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
2221 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2223 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2224 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2225 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2226 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2227 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2228 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2230 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2231 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2233 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2236 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2237 .name = "External Amplifier",
2238 .subdevice = HDA_SUBDEV_NID_FLAG | 0x12,
2239 .info = ad198x_eapd_info,
2240 .get = ad198x_eapd_get,
2241 .put = ad198x_eapd_put,
2242 .private_value = 0x12, /* port-D */
2249 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2250 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2251 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2252 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2253 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2254 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2255 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2257 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2258 /* The multiple "Capture Source" controls confuse alsamixer
2259 * So call somewhat different..
2261 /* .name = "Capture Source", */
2262 .name = "Input Source",
2264 .info = ad198x_mux_enum_info,
2265 .get = ad198x_mux_enum_get,
2266 .put = ad198x_mux_enum_put,
2271 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2272 struct snd_ctl_elem_info *uinfo)
2274 static char *texts[] = {
2275 "PCM", "ADC1", "ADC2", "ADC3"
2277 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2279 uinfo->value.enumerated.items = 4;
2280 if (uinfo->value.enumerated.item >= 4)
2281 uinfo->value.enumerated.item = 3;
2282 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2286 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2287 struct snd_ctl_elem_value *ucontrol)
2289 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2292 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2295 ucontrol->value.enumerated.item[0] = 0;
2297 sel = snd_hda_codec_read(codec, 0x0b, 0,
2298 AC_VERB_GET_CONNECT_SEL, 0);
2303 ucontrol->value.enumerated.item[0] = sel;
2308 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2309 struct snd_ctl_elem_value *ucontrol)
2311 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2312 unsigned int val, sel;
2315 val = ucontrol->value.enumerated.item[0];
2319 sel = snd_hda_codec_read(codec, 0x1d, 0,
2320 AC_VERB_GET_AMP_GAIN_MUTE,
2322 change = sel & 0x80;
2324 snd_hda_codec_write_cache(codec, 0x1d, 0,
2325 AC_VERB_SET_AMP_GAIN_MUTE,
2327 snd_hda_codec_write_cache(codec, 0x1d, 0,
2328 AC_VERB_SET_AMP_GAIN_MUTE,
2332 sel = snd_hda_codec_read(codec, 0x1d, 0,
2333 AC_VERB_GET_AMP_GAIN_MUTE,
2334 AC_AMP_GET_INPUT | 0x01);
2335 change = sel & 0x80;
2337 snd_hda_codec_write_cache(codec, 0x1d, 0,
2338 AC_VERB_SET_AMP_GAIN_MUTE,
2340 snd_hda_codec_write_cache(codec, 0x1d, 0,
2341 AC_VERB_SET_AMP_GAIN_MUTE,
2344 sel = snd_hda_codec_read(codec, 0x0b, 0,
2345 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2346 change |= sel != val;
2348 snd_hda_codec_write_cache(codec, 0x0b, 0,
2349 AC_VERB_SET_CONNECT_SEL,
2355 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2356 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2358 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2359 .name = "IEC958 Playback Source",
2360 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
2361 .info = ad1988_spdif_playback_source_info,
2362 .get = ad1988_spdif_playback_source_get,
2363 .put = ad1988_spdif_playback_source_put,
2368 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2369 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2373 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2374 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2375 HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2380 * initialization verbs
2384 * for 6-stack (+dig)
2386 static struct hda_verb ad1988_6stack_init_verbs[] = {
2387 /* Front, Surround, CLFE, side DAC; unmute as default */
2388 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2389 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2390 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2391 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2392 /* Port-A front headphon path */
2393 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2394 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2395 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2396 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2397 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2398 /* Port-D line-out path */
2399 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2400 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2401 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2402 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2403 /* Port-F surround path */
2404 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2405 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2406 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2407 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2408 /* Port-G CLFE path */
2409 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2410 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2411 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2412 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2413 /* Port-H side path */
2414 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2415 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2416 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2417 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2419 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2420 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2421 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2422 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2423 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2424 /* Port-B front mic-in path */
2425 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2426 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2427 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2428 /* Port-C line-in path */
2429 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2430 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2431 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2432 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2433 /* Port-E mic-in path */
2434 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2435 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2436 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2437 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2438 /* Analog CD Input */
2439 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2440 /* Analog Mix output amp */
2441 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2446 static struct hda_verb ad1988_capture_init_verbs[] = {
2447 /* mute analog mix */
2448 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2449 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2450 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2451 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2452 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2453 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2454 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2455 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2456 /* select ADCs - front-mic */
2457 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2458 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2459 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2464 static struct hda_verb ad1988_spdif_init_verbs[] = {
2466 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2467 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2468 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2469 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2471 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2476 static struct hda_verb ad1988_spdif_in_init_verbs[] = {
2477 /* unmute SPDIF input pin */
2478 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2482 /* AD1989 has no ADC -> SPDIF route */
2483 static struct hda_verb ad1989_spdif_init_verbs[] = {
2484 /* SPDIF-1 out pin */
2485 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2486 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2487 /* SPDIF-2/HDMI out pin */
2488 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2489 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2494 * verbs for 3stack (+dig)
2496 static struct hda_verb ad1988_3stack_ch2_init[] = {
2497 /* set port-C to line-in */
2498 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2499 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2500 /* set port-E to mic-in */
2501 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2502 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2506 static struct hda_verb ad1988_3stack_ch6_init[] = {
2507 /* set port-C to surround out */
2508 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2509 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2510 /* set port-E to CLFE out */
2511 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2512 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2516 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2517 { 2, ad1988_3stack_ch2_init },
2518 { 6, ad1988_3stack_ch6_init },
2521 static struct hda_verb ad1988_3stack_init_verbs[] = {
2522 /* Front, Surround, CLFE, side DAC; unmute as default */
2523 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2524 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2525 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2526 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2527 /* Port-A front headphon path */
2528 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2529 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2530 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2531 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2532 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2533 /* Port-D line-out path */
2534 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2535 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2536 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2537 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2539 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2540 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2541 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2542 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2543 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2544 /* Port-B front mic-in path */
2545 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2546 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2547 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2548 /* Port-C line-in/surround path - 6ch mode as default */
2549 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2550 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2551 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2552 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2553 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2554 /* Port-E mic-in/CLFE path - 6ch mode as default */
2555 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2556 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2557 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2558 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2559 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2560 /* mute analog mix */
2561 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2562 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2563 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2564 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2565 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2566 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2567 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2568 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2569 /* select ADCs - front-mic */
2570 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2571 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2572 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2573 /* Analog Mix output amp */
2574 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2579 * verbs for laptop mode (+dig)
2581 static struct hda_verb ad1988_laptop_hp_on[] = {
2582 /* unmute port-A and mute port-D */
2583 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2584 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2587 static struct hda_verb ad1988_laptop_hp_off[] = {
2588 /* mute port-A and unmute port-D */
2589 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2590 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2594 #define AD1988_HP_EVENT 0x01
2596 static struct hda_verb ad1988_laptop_init_verbs[] = {
2597 /* Front, Surround, CLFE, side DAC; unmute as default */
2598 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2599 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2600 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2601 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2602 /* Port-A front headphon path */
2603 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2604 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2605 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2606 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2607 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2608 /* unsolicited event for pin-sense */
2609 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2610 /* Port-D line-out path + EAPD */
2611 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2612 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2613 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2614 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2615 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2617 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2618 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2619 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2620 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2621 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2622 /* Port-B mic-in path */
2623 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2624 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2625 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2626 /* Port-C docking station - try to output */
2627 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2628 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2629 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2630 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2631 /* mute analog mix */
2632 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2633 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2634 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2635 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2636 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2637 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2638 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2639 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2640 /* select ADCs - mic */
2641 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2642 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2643 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2644 /* Analog Mix output amp */
2645 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2649 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2651 if ((res >> 26) != AD1988_HP_EVENT)
2653 if (snd_hda_jack_detect(codec, 0x11))
2654 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2656 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2659 #ifdef CONFIG_SND_HDA_POWER_SAVE
2660 static struct hda_amp_list ad1988_loopbacks[] = {
2661 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2662 { 0x20, HDA_INPUT, 1 }, /* Line */
2663 { 0x20, HDA_INPUT, 4 }, /* Mic */
2664 { 0x20, HDA_INPUT, 6 }, /* CD */
2670 * Automatic parse of I/O pins from the BIOS configuration
2678 static struct snd_kcontrol_new ad1988_control_templates[] = {
2679 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2680 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2681 HDA_BIND_MUTE(NULL, 0, 0, 0),
2684 /* add dynamic controls */
2685 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2688 struct snd_kcontrol_new *knew;
2690 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2691 knew = snd_array_new(&spec->kctls);
2694 *knew = ad1988_control_templates[type];
2695 knew->name = kstrdup(name, GFP_KERNEL);
2698 if (get_amp_nid_(val))
2699 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2700 knew->private_value = val;
2704 #define AD1988_PIN_CD_NID 0x18
2705 #define AD1988_PIN_BEEP_NID 0x10
2707 static hda_nid_t ad1988_mixer_nids[8] = {
2708 /* A B C D E F G H */
2709 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2712 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2714 static hda_nid_t idx_to_dac[8] = {
2715 /* A B C D E F G H */
2716 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2718 static hda_nid_t idx_to_dac_rev2[8] = {
2719 /* A B C D E F G H */
2720 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2723 return idx_to_dac_rev2[idx];
2725 return idx_to_dac[idx];
2728 static hda_nid_t ad1988_boost_nids[8] = {
2729 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2732 static int ad1988_pin_idx(hda_nid_t nid)
2734 static hda_nid_t ad1988_io_pins[8] = {
2735 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2738 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2739 if (ad1988_io_pins[i] == nid)
2741 return 0; /* should be -1 */
2744 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2746 static int loopback_idx[8] = {
2747 2, 0, 1, 3, 4, 5, 1, 4
2750 case AD1988_PIN_CD_NID:
2753 return loopback_idx[ad1988_pin_idx(nid)];
2757 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2759 static int adc_idx[8] = {
2760 0, 1, 2, 8, 4, 3, 6, 7
2763 case AD1988_PIN_CD_NID:
2766 return adc_idx[ad1988_pin_idx(nid)];
2770 /* fill in the dac_nids table from the parsed pin configuration */
2771 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2772 const struct auto_pin_cfg *cfg)
2774 struct ad198x_spec *spec = codec->spec;
2777 spec->multiout.dac_nids = spec->private_dac_nids;
2779 /* check the pins hardwired to audio widget */
2780 for (i = 0; i < cfg->line_outs; i++) {
2781 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2782 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2784 spec->multiout.num_dacs = cfg->line_outs;
2788 /* add playback controls from the parsed DAC table */
2789 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2790 const struct auto_pin_cfg *cfg)
2793 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2797 for (i = 0; i < cfg->line_outs; i++) {
2798 hda_nid_t dac = spec->multiout.dac_nids[i];
2801 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2804 err = add_control(spec, AD_CTL_WIDGET_VOL,
2805 "Center Playback Volume",
2806 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2809 err = add_control(spec, AD_CTL_WIDGET_VOL,
2810 "LFE Playback Volume",
2811 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2814 err = add_control(spec, AD_CTL_BIND_MUTE,
2815 "Center Playback Switch",
2816 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2819 err = add_control(spec, AD_CTL_BIND_MUTE,
2820 "LFE Playback Switch",
2821 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2825 sprintf(name, "%s Playback Volume", chname[i]);
2826 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2827 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2830 sprintf(name, "%s Playback Switch", chname[i]);
2831 err = add_control(spec, AD_CTL_BIND_MUTE, name,
2832 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2840 /* add playback controls for speaker and HP outputs */
2841 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2844 struct ad198x_spec *spec = codec->spec;
2852 idx = ad1988_pin_idx(pin);
2853 nid = ad1988_idx_to_dac(codec, idx);
2854 /* check whether the corresponding DAC was already taken */
2855 for (i = 0; i < spec->autocfg.line_outs; i++) {
2856 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2857 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2861 if (i >= spec->autocfg.line_outs) {
2862 /* specify the DAC as the extra output */
2863 if (!spec->multiout.hp_nid)
2864 spec->multiout.hp_nid = nid;
2866 spec->multiout.extra_out_nid[0] = nid;
2867 /* control HP volume/switch on the output mixer amp */
2868 sprintf(name, "%s Playback Volume", pfx);
2869 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2870 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2874 nid = ad1988_mixer_nids[idx];
2875 sprintf(name, "%s Playback Switch", pfx);
2876 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2877 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2882 /* create input playback/capture controls for the given pin */
2883 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2884 const char *ctlname, int boost)
2889 sprintf(name, "%s Playback Volume", ctlname);
2890 idx = ad1988_pin_to_loopback_idx(pin);
2891 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2892 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2894 sprintf(name, "%s Playback Switch", ctlname);
2895 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2896 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2900 idx = ad1988_pin_idx(pin);
2901 bnid = ad1988_boost_nids[idx];
2903 sprintf(name, "%s Boost", ctlname);
2904 return add_control(spec, AD_CTL_WIDGET_VOL, name,
2905 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2912 /* create playback/capture controls for input pins */
2913 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2914 const struct auto_pin_cfg *cfg)
2916 struct hda_input_mux *imux = &spec->private_imux;
2919 for (i = 0; i < AUTO_PIN_LAST; i++) {
2920 err = new_analog_input(spec, cfg->input_pins[i],
2921 auto_pin_cfg_labels[i],
2922 i <= AUTO_PIN_FRONT_MIC);
2925 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2926 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2929 imux->items[imux->num_items].label = "Mix";
2930 imux->items[imux->num_items].index = 9;
2933 if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2934 "Analog Mix Playback Volume",
2935 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2937 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2938 "Analog Mix Playback Switch",
2939 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2945 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2946 hda_nid_t nid, int pin_type,
2950 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2951 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2953 case 0x11: /* port-A - DAC 04 */
2954 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2956 case 0x14: /* port-B - DAC 06 */
2957 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2959 case 0x15: /* port-C - DAC 05 */
2960 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2962 case 0x17: /* port-E - DAC 0a */
2963 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2965 case 0x13: /* mono - DAC 04 */
2966 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2971 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2973 struct ad198x_spec *spec = codec->spec;
2976 for (i = 0; i < spec->autocfg.line_outs; i++) {
2977 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2978 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2982 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2984 struct ad198x_spec *spec = codec->spec;
2987 pin = spec->autocfg.speaker_pins[0];
2988 if (pin) /* connect to front */
2989 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2990 pin = spec->autocfg.hp_pins[0];
2991 if (pin) /* connect to front */
2992 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2995 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2997 struct ad198x_spec *spec = codec->spec;
3000 for (i = 0; i < AUTO_PIN_LAST; i++) {
3001 hda_nid_t nid = spec->autocfg.input_pins[i];
3005 case 0x15: /* port-C */
3006 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
3008 case 0x17: /* port-E */
3009 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
3012 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3013 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
3014 if (nid != AD1988_PIN_CD_NID)
3015 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3017 idx = ad1988_pin_idx(nid);
3018 if (ad1988_boost_nids[idx])
3019 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
3020 AC_VERB_SET_AMP_GAIN_MUTE,
3025 /* parse the BIOS configuration and set up the alc_spec */
3026 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
3027 static int ad1988_parse_auto_config(struct hda_codec *codec)
3029 struct ad198x_spec *spec = codec->spec;
3032 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3034 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
3036 if (! spec->autocfg.line_outs)
3037 return 0; /* can't find valid BIOS pin config */
3038 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
3039 (err = ad1988_auto_create_extra_out(codec,
3040 spec->autocfg.speaker_pins[0],
3042 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
3043 "Headphone")) < 0 ||
3044 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
3047 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3049 if (spec->autocfg.dig_outs)
3050 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3051 if (spec->autocfg.dig_in_pin)
3052 spec->dig_in_nid = AD1988_SPDIF_IN;
3054 if (spec->kctls.list)
3055 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3057 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
3059 spec->input_mux = &spec->private_imux;
3064 /* init callback for auto-configuration model -- overriding the default init */
3065 static int ad1988_auto_init(struct hda_codec *codec)
3068 ad1988_auto_init_multi_out(codec);
3069 ad1988_auto_init_extra_out(codec);
3070 ad1988_auto_init_analog_input(codec);
3078 static const char *ad1988_models[AD1988_MODEL_LAST] = {
3079 [AD1988_6STACK] = "6stack",
3080 [AD1988_6STACK_DIG] = "6stack-dig",
3081 [AD1988_3STACK] = "3stack",
3082 [AD1988_3STACK_DIG] = "3stack-dig",
3083 [AD1988_LAPTOP] = "laptop",
3084 [AD1988_LAPTOP_DIG] = "laptop-dig",
3085 [AD1988_AUTO] = "auto",
3088 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
3089 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
3090 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
3091 SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
3092 SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
3096 static int patch_ad1988(struct hda_codec *codec)
3098 struct ad198x_spec *spec;
3099 int err, board_config;
3101 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3108 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
3110 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
3111 ad1988_models, ad1988_cfg_tbl);
3112 if (board_config < 0) {
3113 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3115 board_config = AD1988_AUTO;
3118 if (board_config == AD1988_AUTO) {
3119 /* automatic parse from the BIOS config */
3120 err = ad1988_parse_auto_config(codec);
3125 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n");
3126 board_config = AD1988_6STACK;
3130 err = snd_hda_attach_beep_device(codec, 0x10);
3135 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3137 switch (board_config) {
3139 case AD1988_6STACK_DIG:
3140 spec->multiout.max_channels = 8;
3141 spec->multiout.num_dacs = 4;
3143 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
3145 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
3146 spec->input_mux = &ad1988_6stack_capture_source;
3147 spec->num_mixers = 2;
3149 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
3151 spec->mixers[0] = ad1988_6stack_mixers1;
3152 spec->mixers[1] = ad1988_6stack_mixers2;
3153 spec->num_init_verbs = 1;
3154 spec->init_verbs[0] = ad1988_6stack_init_verbs;
3155 if (board_config == AD1988_6STACK_DIG) {
3156 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3157 spec->dig_in_nid = AD1988_SPDIF_IN;
3161 case AD1988_3STACK_DIG:
3162 spec->multiout.max_channels = 6;
3163 spec->multiout.num_dacs = 3;
3165 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
3167 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3168 spec->input_mux = &ad1988_6stack_capture_source;
3169 spec->channel_mode = ad1988_3stack_modes;
3170 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
3171 spec->num_mixers = 2;
3173 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
3175 spec->mixers[0] = ad1988_3stack_mixers1;
3176 spec->mixers[1] = ad1988_3stack_mixers2;
3177 spec->num_init_verbs = 1;
3178 spec->init_verbs[0] = ad1988_3stack_init_verbs;
3179 if (board_config == AD1988_3STACK_DIG)
3180 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3183 case AD1988_LAPTOP_DIG:
3184 spec->multiout.max_channels = 2;
3185 spec->multiout.num_dacs = 1;
3186 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3187 spec->input_mux = &ad1988_laptop_capture_source;
3188 spec->num_mixers = 1;
3189 spec->mixers[0] = ad1988_laptop_mixers;
3190 spec->inv_eapd = 1; /* inverted EAPD */
3191 spec->num_init_verbs = 1;
3192 spec->init_verbs[0] = ad1988_laptop_init_verbs;
3193 if (board_config == AD1988_LAPTOP_DIG)
3194 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3198 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
3199 spec->adc_nids = ad1988_adc_nids;
3200 spec->capsrc_nids = ad1988_capsrc_nids;
3201 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
3202 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
3203 if (spec->multiout.dig_out_nid) {
3204 if (codec->vendor_id >= 0x11d4989a) {
3205 spec->mixers[spec->num_mixers++] =
3206 ad1989_spdif_out_mixers;
3207 spec->init_verbs[spec->num_init_verbs++] =
3208 ad1989_spdif_init_verbs;
3209 codec->slave_dig_outs = ad1989b_slave_dig_outs;
3211 spec->mixers[spec->num_mixers++] =
3212 ad1988_spdif_out_mixers;
3213 spec->init_verbs[spec->num_init_verbs++] =
3214 ad1988_spdif_init_verbs;
3217 if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a) {
3218 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
3219 spec->init_verbs[spec->num_init_verbs++] =
3220 ad1988_spdif_in_init_verbs;
3223 codec->patch_ops = ad198x_patch_ops;
3224 switch (board_config) {
3226 codec->patch_ops.init = ad1988_auto_init;
3229 case AD1988_LAPTOP_DIG:
3230 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
3233 #ifdef CONFIG_SND_HDA_POWER_SAVE
3234 spec->loopback.amplist = ad1988_loopbacks;
3236 spec->vmaster_nid = 0x04;
3238 codec->no_trigger_sense = 1;
3247 * port-B - front line/mic-in
3248 * port-E - aux in/out
3249 * port-F - aux in/out
3250 * port-C - rear line/mic-in
3251 * port-D - rear line/hp-out
3252 * port-A - front line/hp-out
3254 * AD1984 = AD1884 + two digital mic-ins
3257 * For simplicity, we share the single DAC for both HP and line-outs
3258 * right now. The inidividual playbacks could be easily implemented,
3259 * but no build-up framework is given, so far.
3262 static hda_nid_t ad1884_dac_nids[1] = {
3266 static hda_nid_t ad1884_adc_nids[2] = {
3270 static hda_nid_t ad1884_capsrc_nids[2] = {
3274 #define AD1884_SPDIF_OUT 0x02
3276 static struct hda_input_mux ad1884_capture_source = {
3279 { "Front Mic", 0x0 },
3286 static struct snd_kcontrol_new ad1884_base_mixers[] = {
3287 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3288 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3289 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3290 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3291 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3292 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3293 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3294 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3295 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3296 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3297 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3298 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3299 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3300 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3301 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3302 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3303 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3304 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3306 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3307 /* The multiple "Capture Source" controls confuse alsamixer
3308 * So call somewhat different..
3310 /* .name = "Capture Source", */
3311 .name = "Input Source",
3313 .info = ad198x_mux_enum_info,
3314 .get = ad198x_mux_enum_get,
3315 .put = ad198x_mux_enum_put,
3317 /* SPDIF controls */
3318 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3320 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3321 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3322 /* identical with ad1983 */
3323 .info = ad1983_spdif_route_info,
3324 .get = ad1983_spdif_route_get,
3325 .put = ad1983_spdif_route_put,
3330 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3331 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3332 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3333 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3335 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3341 * initialization verbs
3343 static struct hda_verb ad1884_init_verbs[] = {
3344 /* DACs; mute as default */
3345 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3346 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3347 /* Port-A (HP) mixer */
3348 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3349 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3351 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3352 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3353 /* HP selector - select DAC2 */
3354 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3355 /* Port-D (Line-out) mixer */
3356 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3357 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3359 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3360 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3361 /* Mono-out mixer */
3362 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3363 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3365 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3366 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3368 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3369 /* Port-B (front mic) pin */
3370 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3371 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3372 /* Port-C (rear mic) pin */
3373 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3374 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3375 /* Analog mixer; mute as default */
3376 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3377 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3378 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3379 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3380 /* Analog Mix output amp */
3381 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3382 /* SPDIF output selector */
3383 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3384 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3388 #ifdef CONFIG_SND_HDA_POWER_SAVE
3389 static struct hda_amp_list ad1884_loopbacks[] = {
3390 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3391 { 0x20, HDA_INPUT, 1 }, /* Mic */
3392 { 0x20, HDA_INPUT, 2 }, /* CD */
3393 { 0x20, HDA_INPUT, 4 }, /* Docking */
3398 static const char *ad1884_slave_vols[] = {
3399 "PCM Playback Volume",
3400 "Mic Playback Volume",
3401 "Mono Playback Volume",
3402 "Front Mic Playback Volume",
3403 "Mic Playback Volume",
3404 "CD Playback Volume",
3405 "Internal Mic Playback Volume",
3406 "Docking Mic Playback Volume",
3407 /* "Beep Playback Volume", */
3408 "IEC958 Playback Volume",
3412 static int patch_ad1884(struct hda_codec *codec)
3414 struct ad198x_spec *spec;
3417 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3423 err = snd_hda_attach_beep_device(codec, 0x10);
3428 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3430 spec->multiout.max_channels = 2;
3431 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3432 spec->multiout.dac_nids = ad1884_dac_nids;
3433 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3434 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3435 spec->adc_nids = ad1884_adc_nids;
3436 spec->capsrc_nids = ad1884_capsrc_nids;
3437 spec->input_mux = &ad1884_capture_source;
3438 spec->num_mixers = 1;
3439 spec->mixers[0] = ad1884_base_mixers;
3440 spec->num_init_verbs = 1;
3441 spec->init_verbs[0] = ad1884_init_verbs;
3442 spec->spdif_route = 0;
3443 #ifdef CONFIG_SND_HDA_POWER_SAVE
3444 spec->loopback.amplist = ad1884_loopbacks;
3446 spec->vmaster_nid = 0x04;
3447 /* we need to cover all playback volumes */
3448 spec->slave_vols = ad1884_slave_vols;
3450 codec->patch_ops = ad198x_patch_ops;
3452 codec->no_trigger_sense = 1;
3458 * Lenovo Thinkpad T61/X61
3460 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3464 { "Internal Mic", 0x1 },
3466 { "Docking-Station", 0x4 },
3472 * Dell Precision T3400
3474 static struct hda_input_mux ad1984_dell_desktop_capture_source = {
3477 { "Front Mic", 0x0 },
3484 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3485 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3486 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3487 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3488 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3489 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3490 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3491 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3492 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3493 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3494 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3495 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3496 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3497 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3498 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3499 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3500 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3501 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3503 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3504 /* The multiple "Capture Source" controls confuse alsamixer
3505 * So call somewhat different..
3507 /* .name = "Capture Source", */
3508 .name = "Input Source",
3510 .info = ad198x_mux_enum_info,
3511 .get = ad198x_mux_enum_get,
3512 .put = ad198x_mux_enum_put,
3514 /* SPDIF controls */
3515 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3517 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3518 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3519 /* identical with ad1983 */
3520 .info = ad1983_spdif_route_info,
3521 .get = ad1983_spdif_route_get,
3522 .put = ad1983_spdif_route_put,
3527 /* additional verbs */
3528 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3529 /* Port-E (docking station mic) pin */
3530 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3531 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3532 /* docking mic boost */
3533 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3534 /* Analog mixer - docking mic; mute as default */
3535 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3536 /* enable EAPD bit */
3537 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3542 * Dell Precision T3400
3544 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3545 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3546 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3547 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3548 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3549 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3550 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3551 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3552 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3553 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3554 HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3555 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3556 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3557 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3558 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3559 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3561 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3562 /* The multiple "Capture Source" controls confuse alsamixer
3563 * So call somewhat different..
3565 /* .name = "Capture Source", */
3566 .name = "Input Source",
3568 .info = ad198x_mux_enum_info,
3569 .get = ad198x_mux_enum_get,
3570 .put = ad198x_mux_enum_put,
3575 /* Digial MIC ADC NID 0x05 + 0x06 */
3576 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3577 struct hda_codec *codec,
3578 unsigned int stream_tag,
3579 unsigned int format,
3580 struct snd_pcm_substream *substream)
3582 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3583 stream_tag, 0, format);
3587 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3588 struct hda_codec *codec,
3589 struct snd_pcm_substream *substream)
3591 snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number);
3595 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3601 .prepare = ad1984_pcm_dmic_prepare,
3602 .cleanup = ad1984_pcm_dmic_cleanup
3606 static int ad1984_build_pcms(struct hda_codec *codec)
3608 struct ad198x_spec *spec = codec->spec;
3609 struct hda_pcm *info;
3612 err = ad198x_build_pcms(codec);
3616 info = spec->pcm_rec + codec->num_pcms;
3618 info->name = "AD1984 Digital Mic";
3619 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3627 AD1984_DELL_DESKTOP,
3631 static const char *ad1984_models[AD1984_MODELS] = {
3632 [AD1984_BASIC] = "basic",
3633 [AD1984_THINKPAD] = "thinkpad",
3634 [AD1984_DELL_DESKTOP] = "dell_desktop",
3637 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3638 /* Lenovo Thinkpad T61/X61 */
3639 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD),
3640 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3644 static int patch_ad1984(struct hda_codec *codec)
3646 struct ad198x_spec *spec;
3647 int board_config, err;
3649 err = patch_ad1884(codec);
3653 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3654 ad1984_models, ad1984_cfg_tbl);
3655 switch (board_config) {
3657 /* additional digital mics */
3658 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3659 codec->patch_ops.build_pcms = ad1984_build_pcms;
3661 case AD1984_THINKPAD:
3662 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3663 spec->input_mux = &ad1984_thinkpad_capture_source;
3664 spec->mixers[0] = ad1984_thinkpad_mixers;
3665 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3667 case AD1984_DELL_DESKTOP:
3668 spec->multiout.dig_out_nid = 0;
3669 spec->input_mux = &ad1984_dell_desktop_capture_source;
3670 spec->mixers[0] = ad1984_dell_desktop_mixers;
3678 * AD1883 / AD1884A / AD1984A / AD1984B
3680 * port-B (0x14) - front mic-in
3681 * port-E (0x1c) - rear mic-in
3682 * port-F (0x16) - CD / ext out
3683 * port-C (0x15) - rear line-in
3684 * port-D (0x12) - rear line-out
3685 * port-A (0x11) - front hp-out
3687 * AD1984A = AD1884A + digital-mic
3688 * AD1883 = equivalent with AD1984A
3689 * AD1984B = AD1984A + extra SPDIF-out
3692 * We share the single DAC for both HP and line-outs (see AD1884/1984).
3695 static hda_nid_t ad1884a_dac_nids[1] = {
3699 #define ad1884a_adc_nids ad1884_adc_nids
3700 #define ad1884a_capsrc_nids ad1884_capsrc_nids
3702 #define AD1884A_SPDIF_OUT 0x02
3704 static struct hda_input_mux ad1884a_capture_source = {
3707 { "Front Mic", 0x0 },
3715 static struct snd_kcontrol_new ad1884a_base_mixers[] = {
3716 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3717 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3718 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3719 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3720 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3721 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3722 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3723 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3724 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3725 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3726 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
3727 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
3728 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3729 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3730 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3731 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3732 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3733 HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
3734 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3735 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3736 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3737 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3738 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3740 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3741 /* The multiple "Capture Source" controls confuse alsamixer
3742 * So call somewhat different..
3744 /* .name = "Capture Source", */
3745 .name = "Input Source",
3747 .info = ad198x_mux_enum_info,
3748 .get = ad198x_mux_enum_get,
3749 .put = ad198x_mux_enum_put,
3751 /* SPDIF controls */
3752 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3754 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3755 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3756 /* identical with ad1983 */
3757 .info = ad1983_spdif_route_info,
3758 .get = ad1983_spdif_route_get,
3759 .put = ad1983_spdif_route_put,
3765 * initialization verbs
3767 static struct hda_verb ad1884a_init_verbs[] = {
3768 /* DACs; unmute as default */
3769 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3770 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3771 /* Port-A (HP) mixer - route only from analog mixer */
3772 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3773 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3775 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3776 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3777 /* Port-D (Line-out) mixer - route only from analog mixer */
3778 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3779 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3781 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3782 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3783 /* Mono-out mixer - route only from analog mixer */
3784 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3785 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3787 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3788 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3789 /* Port-B (front mic) pin */
3790 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3791 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3792 /* Port-C (rear line-in) pin */
3793 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3794 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3795 /* Port-E (rear mic) pin */
3796 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3797 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3798 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
3799 /* Port-F (CD) pin */
3800 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3801 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3802 /* Analog mixer; mute as default */
3803 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3804 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3805 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3806 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3807 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
3808 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3809 /* Analog Mix output amp */
3810 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3811 /* capture sources */
3812 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
3813 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3814 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3815 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3816 /* SPDIF output amp */
3817 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3821 #ifdef CONFIG_SND_HDA_POWER_SAVE
3822 static struct hda_amp_list ad1884a_loopbacks[] = {
3823 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3824 { 0x20, HDA_INPUT, 1 }, /* Mic */
3825 { 0x20, HDA_INPUT, 2 }, /* CD */
3826 { 0x20, HDA_INPUT, 4 }, /* Docking */
3834 * Port A: Headphone jack
3836 * Port C: Internal MIC
3837 * Port D: Dock Line Out (if enabled)
3838 * Port E: Dock Line In (if enabled)
3839 * Port F: Internal speakers
3842 static int ad1884a_mobile_master_sw_put(struct snd_kcontrol *kcontrol,
3843 struct snd_ctl_elem_value *ucontrol)
3845 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3846 int ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3847 int mute = (!ucontrol->value.integer.value[0] &&
3848 !ucontrol->value.integer.value[1]);
3849 /* toggle GPIO1 according to the mute state */
3850 snd_hda_codec_write_cache(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3855 static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
3856 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3858 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3859 .name = "Master Playback Switch",
3860 .subdevice = HDA_SUBDEV_AMP_FLAG,
3861 .info = snd_hda_mixer_amp_switch_info,
3862 .get = snd_hda_mixer_amp_switch_get,
3863 .put = ad1884a_mobile_master_sw_put,
3864 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
3866 HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3867 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3868 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3869 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3870 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3871 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3872 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3873 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3874 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3875 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3876 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3877 HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3878 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3879 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3883 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
3884 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3885 /*HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
3887 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3888 .name = "Master Playback Switch",
3889 .subdevice = HDA_SUBDEV_AMP_FLAG,
3890 .info = snd_hda_mixer_amp_switch_info,
3891 .get = snd_hda_mixer_amp_switch_get,
3892 .put = ad1884a_mobile_master_sw_put,
3893 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
3895 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3896 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3897 HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
3898 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
3899 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3900 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3904 /* mute internal speaker if HP is plugged */
3905 static void ad1884a_hp_automute(struct hda_codec *codec)
3907 unsigned int present;
3909 present = snd_hda_jack_detect(codec, 0x11);
3910 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3911 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3912 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3913 present ? 0x00 : 0x02);
3916 /* switch to external mic if plugged */
3917 static void ad1884a_hp_automic(struct hda_codec *codec)
3919 unsigned int present;
3921 present = snd_hda_jack_detect(codec, 0x14);
3922 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
3926 #define AD1884A_HP_EVENT 0x37
3927 #define AD1884A_MIC_EVENT 0x36
3929 /* unsolicited event for HP jack sensing */
3930 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
3932 switch (res >> 26) {
3933 case AD1884A_HP_EVENT:
3934 ad1884a_hp_automute(codec);
3936 case AD1884A_MIC_EVENT:
3937 ad1884a_hp_automic(codec);
3942 /* initialize jack-sensing, too */
3943 static int ad1884a_hp_init(struct hda_codec *codec)
3946 ad1884a_hp_automute(codec);
3947 ad1884a_hp_automic(codec);
3951 /* mute internal speaker if HP or docking HP is plugged */
3952 static void ad1884a_laptop_automute(struct hda_codec *codec)
3954 unsigned int present;
3956 present = snd_hda_jack_detect(codec, 0x11);
3958 present = snd_hda_jack_detect(codec, 0x12);
3959 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3960 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3961 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3962 present ? 0x00 : 0x02);
3965 /* switch to external mic if plugged */
3966 static void ad1884a_laptop_automic(struct hda_codec *codec)
3970 if (snd_hda_jack_detect(codec, 0x14))
3972 else if (snd_hda_jack_detect(codec, 0x1c))
3976 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, idx);
3979 /* unsolicited event for HP jack sensing */
3980 static void ad1884a_laptop_unsol_event(struct hda_codec *codec,
3983 switch (res >> 26) {
3984 case AD1884A_HP_EVENT:
3985 ad1884a_laptop_automute(codec);
3987 case AD1884A_MIC_EVENT:
3988 ad1884a_laptop_automic(codec);
3993 /* initialize jack-sensing, too */
3994 static int ad1884a_laptop_init(struct hda_codec *codec)
3997 ad1884a_laptop_automute(codec);
3998 ad1884a_laptop_automic(codec);
4002 /* additional verbs for laptop model */
4003 static struct hda_verb ad1884a_laptop_verbs[] = {
4004 /* Port-A (HP) pin - always unmuted */
4005 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4006 /* Port-F (int speaker) mixer - route only from analog mixer */
4007 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4008 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4009 /* Port-F (int speaker) pin */
4010 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4011 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4012 /* required for compaq 6530s/6531s speaker output */
4013 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4014 /* Port-C pin - internal mic-in */
4015 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4016 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4017 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4018 /* Port-D (docking line-out) pin - default unmuted */
4019 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4021 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4022 /* unsolicited event for pin-sense */
4023 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4024 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4025 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4026 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4027 /* allow to touch GPIO1 (for mute control) */
4028 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4029 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4030 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4034 static struct hda_verb ad1884a_mobile_verbs[] = {
4035 /* DACs; unmute as default */
4036 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4037 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4038 /* Port-A (HP) mixer - route only from analog mixer */
4039 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4040 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4042 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4043 /* Port-A (HP) pin - always unmuted */
4044 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4045 /* Port-B (mic jack) pin */
4046 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4047 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4048 /* Port-C (int mic) pin */
4049 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4050 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4051 /* Port-F (int speaker) mixer - route only from analog mixer */
4052 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4053 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4055 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4056 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4057 /* Analog mixer; mute as default */
4058 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4059 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4060 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4061 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4062 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4063 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4064 /* Analog Mix output amp */
4065 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4066 /* capture sources */
4067 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4068 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4069 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4070 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4071 /* unsolicited event for pin-sense */
4072 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4073 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4074 /* allow to touch GPIO1 (for mute control) */
4075 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4076 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4077 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4086 * 0x17 - built-in mic
4089 static struct hda_verb ad1984a_thinkpad_verbs[] = {
4091 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4093 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4095 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4096 /* unsolicited event for pin-sense */
4097 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4098 /* internal mic - dmic */
4099 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4100 /* set magic COEFs for dmic */
4101 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4102 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4106 static struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
4107 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4108 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
4109 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4110 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4111 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4112 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4113 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
4114 HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
4115 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4116 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4118 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4119 .name = "Capture Source",
4120 .info = ad198x_mux_enum_info,
4121 .get = ad198x_mux_enum_get,
4122 .put = ad198x_mux_enum_put,
4127 static struct hda_input_mux ad1984a_thinkpad_capture_source = {
4131 { "Internal Mic", 0x5 },
4136 /* mute internal speaker if HP is plugged */
4137 static void ad1984a_thinkpad_automute(struct hda_codec *codec)
4139 unsigned int present;
4141 present = snd_hda_jack_detect(codec, 0x11);
4142 snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
4143 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4146 /* unsolicited event for HP jack sensing */
4147 static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec,
4150 if ((res >> 26) != AD1884A_HP_EVENT)
4152 ad1984a_thinkpad_automute(codec);
4155 /* initialize jack-sensing, too */
4156 static int ad1984a_thinkpad_init(struct hda_codec *codec)
4159 ad1984a_thinkpad_automute(codec);
4165 * port-A (0x11) - front hp-out
4166 * port-B (0x14) - unused
4167 * port-C (0x15) - unused
4168 * port-D (0x12) - rear line out
4169 * port-E (0x1c) - front mic-in
4170 * port-F (0x16) - Internal speakers
4171 * digital-mic (0x17) - Internal mic
4174 static struct hda_verb ad1984a_touchsmart_verbs[] = {
4175 /* DACs; unmute as default */
4176 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4177 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4178 /* Port-A (HP) mixer - route only from analog mixer */
4179 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4180 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4182 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4183 /* Port-A (HP) pin - always unmuted */
4184 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4185 /* Port-E (int speaker) mixer - route only from analog mixer */
4186 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, 0x03},
4188 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4189 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4190 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4191 /* Port-F (int speaker) mixer - route only from analog mixer */
4192 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4193 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4195 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4196 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4197 /* Analog mixer; mute as default */
4198 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4199 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4200 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4201 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4202 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4203 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4204 /* Analog Mix output amp */
4205 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4206 /* capture sources */
4207 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4208 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4209 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4210 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4211 /* unsolicited event for pin-sense */
4212 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4213 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4214 /* allow to touch GPIO1 (for mute control) */
4215 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4216 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4217 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4218 /* internal mic - dmic */
4219 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4220 /* set magic COEFs for dmic */
4221 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4222 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4226 static struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = {
4227 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4228 /* HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
4230 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4231 .subdevice = HDA_SUBDEV_AMP_FLAG,
4232 .name = "Master Playback Switch",
4233 .info = snd_hda_mixer_amp_switch_info,
4234 .get = snd_hda_mixer_amp_switch_get,
4235 .put = ad1884a_mobile_master_sw_put,
4236 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4238 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4239 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4240 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4241 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4242 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
4243 HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
4247 /* switch to external mic if plugged */
4248 static void ad1984a_touchsmart_automic(struct hda_codec *codec)
4250 if (snd_hda_jack_detect(codec, 0x1c))
4251 snd_hda_codec_write(codec, 0x0c, 0,
4252 AC_VERB_SET_CONNECT_SEL, 0x4);
4254 snd_hda_codec_write(codec, 0x0c, 0,
4255 AC_VERB_SET_CONNECT_SEL, 0x5);
4259 /* unsolicited event for HP jack sensing */
4260 static void ad1984a_touchsmart_unsol_event(struct hda_codec *codec,
4263 switch (res >> 26) {
4264 case AD1884A_HP_EVENT:
4265 ad1884a_hp_automute(codec);
4267 case AD1884A_MIC_EVENT:
4268 ad1984a_touchsmart_automic(codec);
4273 /* initialize jack-sensing, too */
4274 static int ad1984a_touchsmart_init(struct hda_codec *codec)
4277 ad1884a_hp_automute(codec);
4278 ad1984a_touchsmart_automic(codec);
4295 static const char *ad1884a_models[AD1884A_MODELS] = {
4296 [AD1884A_DESKTOP] = "desktop",
4297 [AD1884A_LAPTOP] = "laptop",
4298 [AD1884A_MOBILE] = "mobile",
4299 [AD1884A_THINKPAD] = "thinkpad",
4300 [AD1984A_TOUCHSMART] = "touchsmart",
4303 static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
4304 SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
4305 SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
4306 SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
4307 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE),
4308 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30d0, "HP laptop", AD1884A_LAPTOP),
4309 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP),
4310 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP),
4311 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x7010, "HP laptop", AD1884A_MOBILE),
4312 SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
4313 SND_PCI_QUIRK(0x103c, 0x2a82, "Touchsmart", AD1984A_TOUCHSMART),
4317 static int patch_ad1884a(struct hda_codec *codec)
4319 struct ad198x_spec *spec;
4320 int err, board_config;
4322 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4328 err = snd_hda_attach_beep_device(codec, 0x10);
4333 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4335 spec->multiout.max_channels = 2;
4336 spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
4337 spec->multiout.dac_nids = ad1884a_dac_nids;
4338 spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
4339 spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
4340 spec->adc_nids = ad1884a_adc_nids;
4341 spec->capsrc_nids = ad1884a_capsrc_nids;
4342 spec->input_mux = &ad1884a_capture_source;
4343 spec->num_mixers = 1;
4344 spec->mixers[0] = ad1884a_base_mixers;
4345 spec->num_init_verbs = 1;
4346 spec->init_verbs[0] = ad1884a_init_verbs;
4347 spec->spdif_route = 0;
4348 #ifdef CONFIG_SND_HDA_POWER_SAVE
4349 spec->loopback.amplist = ad1884a_loopbacks;
4351 codec->patch_ops = ad198x_patch_ops;
4353 /* override some parameters */
4354 board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
4357 switch (board_config) {
4358 case AD1884A_LAPTOP:
4359 spec->mixers[0] = ad1884a_laptop_mixers;
4360 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
4361 spec->multiout.dig_out_nid = 0;
4362 codec->patch_ops.unsol_event = ad1884a_laptop_unsol_event;
4363 codec->patch_ops.init = ad1884a_laptop_init;
4364 /* set the upper-limit for mixer amp to 0dB for avoiding the
4365 * possible damage by overloading
4367 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4368 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4369 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4370 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4371 (1 << AC_AMPCAP_MUTE_SHIFT));
4373 case AD1884A_MOBILE:
4374 spec->mixers[0] = ad1884a_mobile_mixers;
4375 spec->init_verbs[0] = ad1884a_mobile_verbs;
4376 spec->multiout.dig_out_nid = 0;
4377 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
4378 codec->patch_ops.init = ad1884a_hp_init;
4379 /* set the upper-limit for mixer amp to 0dB for avoiding the
4380 * possible damage by overloading
4382 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4383 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4384 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4385 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4386 (1 << AC_AMPCAP_MUTE_SHIFT));
4388 case AD1884A_THINKPAD:
4389 spec->mixers[0] = ad1984a_thinkpad_mixers;
4390 spec->init_verbs[spec->num_init_verbs++] =
4391 ad1984a_thinkpad_verbs;
4392 spec->multiout.dig_out_nid = 0;
4393 spec->input_mux = &ad1984a_thinkpad_capture_source;
4394 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
4395 codec->patch_ops.init = ad1984a_thinkpad_init;
4397 case AD1984A_TOUCHSMART:
4398 spec->mixers[0] = ad1984a_touchsmart_mixers;
4399 spec->init_verbs[0] = ad1984a_touchsmart_verbs;
4400 spec->multiout.dig_out_nid = 0;
4401 codec->patch_ops.unsol_event = ad1984a_touchsmart_unsol_event;
4402 codec->patch_ops.init = ad1984a_touchsmart_init;
4403 /* set the upper-limit for mixer amp to 0dB for avoiding the
4404 * possible damage by overloading
4406 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4407 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4408 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4409 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4410 (1 << AC_AMPCAP_MUTE_SHIFT));
4414 codec->no_trigger_sense = 1;
4423 * port-A - front hp-out
4424 * port-B - front mic-in
4425 * port-C - rear line-in, shared surr-out (3stack)
4426 * port-D - rear line-out
4427 * port-E - rear mic-in, shared clfe-out (3stack)
4428 * port-F - rear surr-out (6stack)
4429 * port-G - rear clfe-out (6stack)
4432 static hda_nid_t ad1882_dac_nids[3] = {
4436 static hda_nid_t ad1882_adc_nids[2] = {
4440 static hda_nid_t ad1882_capsrc_nids[2] = {
4444 #define AD1882_SPDIF_OUT 0x02
4446 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
4447 static struct hda_input_mux ad1882_capture_source = {
4450 { "Front Mic", 0x1 },
4458 /* list: 0x11, 0x39, 0x3a, 0x3c, 0x18, 0x1f, 0x12, 0x20 */
4459 static struct hda_input_mux ad1882a_capture_source = {
4462 { "Front Mic", 0x1 },
4465 { "Digital Mic", 0x06 },
4470 static struct snd_kcontrol_new ad1882_base_mixers[] = {
4471 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
4472 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
4473 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
4474 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
4475 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
4476 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4477 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
4478 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
4480 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
4481 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
4482 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
4483 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4484 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4485 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
4486 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
4488 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4489 /* The multiple "Capture Source" controls confuse alsamixer
4490 * So call somewhat different..
4492 /* .name = "Capture Source", */
4493 .name = "Input Source",
4495 .info = ad198x_mux_enum_info,
4496 .get = ad198x_mux_enum_get,
4497 .put = ad198x_mux_enum_put,
4499 /* SPDIF controls */
4500 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
4502 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4503 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4504 /* identical with ad1983 */
4505 .info = ad1983_spdif_route_info,
4506 .get = ad1983_spdif_route_get,
4507 .put = ad1983_spdif_route_put,
4512 static struct snd_kcontrol_new ad1882_loopback_mixers[] = {
4513 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4514 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4515 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4516 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4517 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
4518 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
4519 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4520 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4524 static struct snd_kcontrol_new ad1882a_loopback_mixers[] = {
4525 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4526 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4527 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4528 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4529 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
4530 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4531 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4532 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4533 HDA_CODEC_VOLUME("Digital Mic Boost", 0x1f, 0x0, HDA_INPUT),
4537 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
4538 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4539 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
4540 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
4542 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4543 .name = "Channel Mode",
4544 .info = ad198x_ch_mode_info,
4545 .get = ad198x_ch_mode_get,
4546 .put = ad198x_ch_mode_put,
4551 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
4552 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
4553 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
4554 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
4558 static struct hda_verb ad1882_ch2_init[] = {
4559 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4560 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4561 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4562 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4563 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4564 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4568 static struct hda_verb ad1882_ch4_init[] = {
4569 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4570 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4571 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4572 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4573 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4574 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4578 static struct hda_verb ad1882_ch6_init[] = {
4579 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4580 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4581 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4582 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4583 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4584 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4588 static struct hda_channel_mode ad1882_modes[3] = {
4589 { 2, ad1882_ch2_init },
4590 { 4, ad1882_ch4_init },
4591 { 6, ad1882_ch6_init },
4595 * initialization verbs
4597 static struct hda_verb ad1882_init_verbs[] = {
4598 /* DACs; mute as default */
4599 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4600 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4601 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4602 /* Port-A (HP) mixer */
4603 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4604 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4606 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4607 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4608 /* HP selector - select DAC2 */
4609 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
4610 /* Port-D (Line-out) mixer */
4611 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4612 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4614 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4615 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4616 /* Mono-out mixer */
4617 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4618 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4620 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4621 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4622 /* Port-B (front mic) pin */
4623 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4624 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4625 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4626 /* Port-C (line-in) pin */
4627 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4628 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4629 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4630 /* Port-C mixer - mute as input */
4631 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4632 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4633 /* Port-E (mic-in) pin */
4634 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4635 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4636 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4637 /* Port-E mixer - mute as input */
4638 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4639 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4640 /* Port-F (surround) */
4641 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4642 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4644 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4645 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4646 /* Analog mixer; mute as default */
4647 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
4648 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4649 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4650 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4651 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4652 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4653 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4654 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
4655 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4656 /* Analog Mix output amp */
4657 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
4658 /* SPDIF output selector */
4659 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4660 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
4661 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4665 #ifdef CONFIG_SND_HDA_POWER_SAVE
4666 static struct hda_amp_list ad1882_loopbacks[] = {
4667 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4668 { 0x20, HDA_INPUT, 1 }, /* Mic */
4669 { 0x20, HDA_INPUT, 4 }, /* Line */
4670 { 0x20, HDA_INPUT, 6 }, /* CD */
4682 static const char *ad1882_models[AD1986A_MODELS] = {
4683 [AD1882_3STACK] = "3stack",
4684 [AD1882_6STACK] = "6stack",
4688 static int patch_ad1882(struct hda_codec *codec)
4690 struct ad198x_spec *spec;
4691 int err, board_config;
4693 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4699 err = snd_hda_attach_beep_device(codec, 0x10);
4704 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4706 spec->multiout.max_channels = 6;
4707 spec->multiout.num_dacs = 3;
4708 spec->multiout.dac_nids = ad1882_dac_nids;
4709 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
4710 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
4711 spec->adc_nids = ad1882_adc_nids;
4712 spec->capsrc_nids = ad1882_capsrc_nids;
4713 if (codec->vendor_id == 0x11d41882)
4714 spec->input_mux = &ad1882_capture_source;
4716 spec->input_mux = &ad1882a_capture_source;
4717 spec->num_mixers = 2;
4718 spec->mixers[0] = ad1882_base_mixers;
4719 if (codec->vendor_id == 0x11d41882)
4720 spec->mixers[1] = ad1882_loopback_mixers;
4722 spec->mixers[1] = ad1882a_loopback_mixers;
4723 spec->num_init_verbs = 1;
4724 spec->init_verbs[0] = ad1882_init_verbs;
4725 spec->spdif_route = 0;
4726 #ifdef CONFIG_SND_HDA_POWER_SAVE
4727 spec->loopback.amplist = ad1882_loopbacks;
4729 spec->vmaster_nid = 0x04;
4731 codec->patch_ops = ad198x_patch_ops;
4733 /* override some parameters */
4734 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
4735 ad1882_models, NULL);
4736 switch (board_config) {
4739 spec->num_mixers = 3;
4740 spec->mixers[2] = ad1882_3stack_mixers;
4741 spec->channel_mode = ad1882_modes;
4742 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
4743 spec->need_dac_fix = 1;
4744 spec->multiout.max_channels = 2;
4745 spec->multiout.num_dacs = 1;
4748 spec->num_mixers = 3;
4749 spec->mixers[2] = ad1882_6stack_mixers;
4753 codec->no_trigger_sense = 1;
4762 static struct hda_codec_preset snd_hda_preset_analog[] = {
4763 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
4764 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
4765 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
4766 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
4767 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
4768 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
4769 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
4770 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
4771 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
4772 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
4773 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
4774 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
4775 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 },
4776 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },
4777 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },
4781 MODULE_ALIAS("snd-hda-codec-id:11d4*");
4783 MODULE_LICENSE("GPL");
4784 MODULE_DESCRIPTION("Analog Devices HD-audio codec");
4786 static struct hda_codec_preset_list analog_list = {
4787 .preset = snd_hda_preset_analog,
4788 .owner = THIS_MODULE,
4791 static int __init patch_analog_init(void)
4793 return snd_hda_add_codec_preset(&analog_list);
4796 static void __exit patch_analog_exit(void)
4798 snd_hda_delete_codec_preset(&analog_list);
4801 module_init(patch_analog_init)
4802 module_exit(patch_analog_exit)