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;
180 for (i = 0; i < spec->num_mixers; i++) {
181 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
185 if (spec->multiout.dig_out_nid) {
186 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
189 err = snd_hda_create_spdif_share_sw(codec,
193 spec->multiout.share_spdif = 1;
195 if (spec->dig_in_nid) {
196 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
201 /* create beep controls if needed */
202 #ifdef CONFIG_SND_HDA_INPUT_BEEP
203 if (spec->beep_amp) {
204 struct snd_kcontrol_new *knew;
205 for (knew = ad_beep_mixer; knew->name; knew++) {
206 struct snd_kcontrol *kctl;
207 kctl = snd_ctl_new1(knew, codec);
210 kctl->private_value = spec->beep_amp;
211 err = snd_hda_ctl_add(codec,
212 get_amp_nid_(spec->beep_amp),
220 /* if we have no master control, let's create it */
221 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
222 unsigned int vmaster_tlv[4];
223 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
224 HDA_OUTPUT, vmaster_tlv);
225 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
228 spec->slave_vols : ad_slave_vols));
232 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
233 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
236 spec->slave_sws : ad_slave_sws));
241 ad198x_free_kctls(codec); /* no longer needed */
245 #ifdef CONFIG_SND_HDA_POWER_SAVE
246 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
248 struct ad198x_spec *spec = codec->spec;
249 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
254 * Analog playback callbacks
256 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
257 struct hda_codec *codec,
258 struct snd_pcm_substream *substream)
260 struct ad198x_spec *spec = codec->spec;
261 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
265 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
266 struct hda_codec *codec,
267 unsigned int stream_tag,
269 struct snd_pcm_substream *substream)
271 struct ad198x_spec *spec = codec->spec;
272 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
276 static int ad198x_playback_pcm_cleanup(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_cleanup(codec, &spec->multiout);
287 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
288 struct hda_codec *codec,
289 struct snd_pcm_substream *substream)
291 struct ad198x_spec *spec = codec->spec;
292 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
295 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
296 struct hda_codec *codec,
297 struct snd_pcm_substream *substream)
299 struct ad198x_spec *spec = codec->spec;
300 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
303 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
304 struct hda_codec *codec,
305 unsigned int stream_tag,
307 struct snd_pcm_substream *substream)
309 struct ad198x_spec *spec = codec->spec;
310 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
314 static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
315 struct hda_codec *codec,
316 struct snd_pcm_substream *substream)
318 struct ad198x_spec *spec = codec->spec;
319 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
325 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
326 struct hda_codec *codec,
327 unsigned int stream_tag,
329 struct snd_pcm_substream *substream)
331 struct ad198x_spec *spec = codec->spec;
332 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
333 stream_tag, 0, format);
337 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
338 struct hda_codec *codec,
339 struct snd_pcm_substream *substream)
341 struct ad198x_spec *spec = codec->spec;
342 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
349 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
352 .channels_max = 6, /* changed later */
353 .nid = 0, /* fill later */
355 .open = ad198x_playback_pcm_open,
356 .prepare = ad198x_playback_pcm_prepare,
357 .cleanup = ad198x_playback_pcm_cleanup
361 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
365 .nid = 0, /* fill later */
367 .prepare = ad198x_capture_pcm_prepare,
368 .cleanup = ad198x_capture_pcm_cleanup
372 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
376 .nid = 0, /* fill later */
378 .open = ad198x_dig_playback_pcm_open,
379 .close = ad198x_dig_playback_pcm_close,
380 .prepare = ad198x_dig_playback_pcm_prepare,
381 .cleanup = ad198x_dig_playback_pcm_cleanup
385 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
389 /* NID is set in alc_build_pcms */
392 static int ad198x_build_pcms(struct hda_codec *codec)
394 struct ad198x_spec *spec = codec->spec;
395 struct hda_pcm *info = spec->pcm_rec;
398 codec->pcm_info = info;
400 info->name = "AD198x Analog";
401 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
402 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
403 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
404 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
405 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
406 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
408 if (spec->multiout.dig_out_nid) {
411 info->name = "AD198x Digital";
412 info->pcm_type = HDA_PCM_TYPE_SPDIF;
413 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
414 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
415 if (spec->dig_in_nid) {
416 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
417 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
424 static void ad198x_free_kctls(struct hda_codec *codec)
426 struct ad198x_spec *spec = codec->spec;
428 if (spec->kctls.list) {
429 struct snd_kcontrol_new *kctl = spec->kctls.list;
431 for (i = 0; i < spec->kctls.used; i++)
434 snd_array_free(&spec->kctls);
437 static void ad198x_free(struct hda_codec *codec)
439 struct ad198x_spec *spec = codec->spec;
444 ad198x_free_kctls(codec);
446 snd_hda_detach_beep_device(codec);
449 static struct hda_codec_ops ad198x_patch_ops = {
450 .build_controls = ad198x_build_controls,
451 .build_pcms = ad198x_build_pcms,
454 #ifdef CONFIG_SND_HDA_POWER_SAVE
455 .check_power_status = ad198x_check_power_status,
462 * the private value = nid
464 #define ad198x_eapd_info snd_ctl_boolean_mono_info
466 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
467 struct snd_ctl_elem_value *ucontrol)
469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
470 struct ad198x_spec *spec = codec->spec;
472 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
474 ucontrol->value.integer.value[0] = spec->cur_eapd;
478 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
479 struct snd_ctl_elem_value *ucontrol)
481 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
482 struct ad198x_spec *spec = codec->spec;
483 hda_nid_t nid = kcontrol->private_value & 0xff;
485 eapd = !!ucontrol->value.integer.value[0];
488 if (eapd == spec->cur_eapd)
490 spec->cur_eapd = eapd;
491 snd_hda_codec_write_cache(codec, nid,
492 0, AC_VERB_SET_EAPD_BTLENABLE,
497 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
498 struct snd_ctl_elem_info *uinfo);
499 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
500 struct snd_ctl_elem_value *ucontrol);
501 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
502 struct snd_ctl_elem_value *ucontrol);
509 #define AD1986A_SPDIF_OUT 0x02
510 #define AD1986A_FRONT_DAC 0x03
511 #define AD1986A_SURR_DAC 0x04
512 #define AD1986A_CLFE_DAC 0x05
513 #define AD1986A_ADC 0x06
515 static hda_nid_t ad1986a_dac_nids[3] = {
516 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
518 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
519 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
521 static struct hda_input_mux ad1986a_capture_source = {
535 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
536 .ops = &snd_hda_bind_vol,
538 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
539 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
540 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
545 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
546 .ops = &snd_hda_bind_sw,
548 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
549 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
550 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
558 static struct snd_kcontrol_new ad1986a_mixers[] = {
560 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
562 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
563 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
564 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
565 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
566 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
567 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
568 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
569 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
570 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
571 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
572 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
573 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
574 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
575 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
576 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
577 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
578 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
579 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
580 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
581 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
582 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
583 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
584 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
585 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
586 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
588 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
589 .name = "Capture Source",
590 .info = ad198x_mux_enum_info,
591 .get = ad198x_mux_enum_get,
592 .put = ad198x_mux_enum_put,
594 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
598 /* additional mixers for 3stack mode */
599 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
601 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
602 .name = "Channel Mode",
603 .info = ad198x_ch_mode_info,
604 .get = ad198x_ch_mode_get,
605 .put = ad198x_ch_mode_put,
610 /* laptop model - 2ch only */
611 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
613 /* master controls both pins 0x1a and 0x1b */
614 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
615 .ops = &snd_hda_bind_vol,
617 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
618 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
623 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
624 .ops = &snd_hda_bind_sw,
626 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
627 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
632 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
633 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
634 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
635 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
636 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
637 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
638 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
639 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
640 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
641 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
642 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
643 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
644 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
645 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
647 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
648 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
649 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
650 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
652 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
653 .name = "Capture Source",
654 .info = ad198x_mux_enum_info,
655 .get = ad198x_mux_enum_get,
656 .put = ad198x_mux_enum_put,
661 /* laptop-eapd model - 2ch only */
663 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
667 { "Internal Mic", 0x4 },
672 static struct hda_input_mux ad1986a_automic_capture_source = {
680 static struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = {
681 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
682 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
686 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
687 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
688 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
689 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
690 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
691 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
692 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
693 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
695 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
696 .name = "Capture Source",
697 .info = ad198x_mux_enum_info,
698 .get = ad198x_mux_enum_get,
699 .put = ad198x_mux_enum_put,
702 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
703 .name = "External Amplifier",
704 .info = ad198x_eapd_info,
705 .get = ad198x_eapd_get,
706 .put = ad198x_eapd_put,
707 .private_value = 0x1b, /* port-D */
712 static struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {
713 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
714 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
718 /* re-connect the mic boost input according to the jack sensing */
719 static void ad1986a_automic(struct hda_codec *codec)
721 unsigned int present;
722 present = snd_hda_jack_detect(codec, 0x1f);
723 /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
724 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
728 #define AD1986A_MIC_EVENT 0x36
730 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
733 if ((res >> 26) != AD1986A_MIC_EVENT)
735 ad1986a_automic(codec);
738 static int ad1986a_automic_init(struct hda_codec *codec)
741 ad1986a_automic(codec);
745 /* laptop-automute - 2ch only */
747 static void ad1986a_update_hp(struct hda_codec *codec)
749 struct ad198x_spec *spec = codec->spec;
752 if (spec->jack_present)
753 mute = HDA_AMP_MUTE; /* mute internal speaker */
755 /* unmute internal speaker if necessary */
756 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
757 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
761 static void ad1986a_hp_automute(struct hda_codec *codec)
763 struct ad198x_spec *spec = codec->spec;
765 spec->jack_present = snd_hda_jack_detect(codec, 0x1a);
766 if (spec->inv_jack_detect)
767 spec->jack_present = !spec->jack_present;
768 ad1986a_update_hp(codec);
771 #define AD1986A_HP_EVENT 0x37
773 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
775 if ((res >> 26) != AD1986A_HP_EVENT)
777 ad1986a_hp_automute(codec);
780 static int ad1986a_hp_init(struct hda_codec *codec)
783 ad1986a_hp_automute(codec);
787 /* bind hp and internal speaker mute (with plug check) */
788 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
789 struct snd_ctl_elem_value *ucontrol)
791 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
792 long *valp = ucontrol->value.integer.value;
795 change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
797 valp[0] ? 0 : HDA_AMP_MUTE);
798 change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
800 valp[1] ? 0 : HDA_AMP_MUTE);
802 ad1986a_update_hp(codec);
806 static struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {
807 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
809 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
810 .name = "Master Playback Switch",
811 .info = snd_hda_mixer_amp_switch_info,
812 .get = snd_hda_mixer_amp_switch_get,
813 .put = ad1986a_hp_master_sw_put,
814 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
821 * initialization verbs
823 static struct hda_verb ad1986a_init_verbs[] = {
824 /* Front, Surround, CLFE DAC; mute as default */
825 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
826 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
827 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
829 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
830 /* HP, Line-Out, Surround, CLFE selectors */
831 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
832 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
833 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
834 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
836 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
837 /* Mic selector: Mic 1/2 pin */
838 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
839 /* Line-in selector: Line-in */
840 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
842 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
843 /* Record selector: mic */
844 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
845 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
846 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
847 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
848 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
849 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
850 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
852 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
853 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
854 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
855 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
856 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
857 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
858 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
860 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
861 /* Front, Surround, CLFE Pins */
862 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
863 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
864 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
866 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
868 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
869 /* Line, Aux, CD, Beep-In Pin */
870 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
871 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
872 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
873 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
874 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
878 static struct hda_verb ad1986a_ch2_init[] = {
879 /* Surround out -> Line In */
880 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
881 /* Line-in selectors */
882 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
884 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
885 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
886 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
890 static struct hda_verb ad1986a_ch4_init[] = {
891 /* Surround out -> Surround */
892 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
893 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
895 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
896 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
900 static struct hda_verb ad1986a_ch6_init[] = {
901 /* Surround out -> Surround out */
902 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
903 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
905 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
906 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
910 static struct hda_channel_mode ad1986a_modes[3] = {
911 { 2, ad1986a_ch2_init },
912 { 4, ad1986a_ch4_init },
913 { 6, ad1986a_ch6_init },
916 /* eapd initialization */
917 static struct hda_verb ad1986a_eapd_init_verbs[] = {
918 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
922 static struct hda_verb ad1986a_automic_verbs[] = {
923 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
924 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
925 /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
926 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
927 {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
931 /* Ultra initialization */
932 static struct hda_verb ad1986a_ultra_init[] = {
933 /* eapd initialization */
934 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
936 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
937 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
938 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
942 /* pin sensing on HP jack */
943 static struct hda_verb ad1986a_hp_init_verbs[] = {
944 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
948 static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec,
952 case AD1986A_HP_EVENT:
953 ad1986a_hp_automute(codec);
955 case AD1986A_MIC_EVENT:
956 ad1986a_automic(codec);
961 static int ad1986a_samsung_p50_init(struct hda_codec *codec)
964 ad1986a_hp_automute(codec);
965 ad1986a_automic(codec);
976 AD1986A_LAPTOP_AUTOMUTE,
983 static const char *ad1986a_models[AD1986A_MODELS] = {
984 [AD1986A_6STACK] = "6stack",
985 [AD1986A_3STACK] = "3stack",
986 [AD1986A_LAPTOP] = "laptop",
987 [AD1986A_LAPTOP_EAPD] = "laptop-eapd",
988 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
989 [AD1986A_ULTRA] = "ultra",
990 [AD1986A_SAMSUNG] = "samsung",
991 [AD1986A_SAMSUNG_P50] = "samsung-p50",
994 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
995 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
996 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
997 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
998 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
999 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
1000 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
1001 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
1002 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
1003 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
1004 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
1005 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
1006 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
1007 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
1008 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
1009 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
1010 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
1011 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
1012 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
1013 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
1014 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50),
1015 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
1016 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),
1017 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
1018 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
1019 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
1020 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
1021 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
1025 #ifdef CONFIG_SND_HDA_POWER_SAVE
1026 static struct hda_amp_list ad1986a_loopbacks[] = {
1027 { 0x13, HDA_OUTPUT, 0 }, /* Mic */
1028 { 0x14, HDA_OUTPUT, 0 }, /* Phone */
1029 { 0x15, HDA_OUTPUT, 0 }, /* CD */
1030 { 0x16, HDA_OUTPUT, 0 }, /* Aux */
1031 { 0x17, HDA_OUTPUT, 0 }, /* Line */
1036 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
1038 unsigned int conf = snd_hda_codec_get_pincfg(codec, nid);
1039 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
1042 static int patch_ad1986a(struct hda_codec *codec)
1044 struct ad198x_spec *spec;
1045 int err, board_config;
1047 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1053 err = snd_hda_attach_beep_device(codec, 0x19);
1058 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
1060 spec->multiout.max_channels = 6;
1061 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
1062 spec->multiout.dac_nids = ad1986a_dac_nids;
1063 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
1064 spec->num_adc_nids = 1;
1065 spec->adc_nids = ad1986a_adc_nids;
1066 spec->capsrc_nids = ad1986a_capsrc_nids;
1067 spec->input_mux = &ad1986a_capture_source;
1068 spec->num_mixers = 1;
1069 spec->mixers[0] = ad1986a_mixers;
1070 spec->num_init_verbs = 1;
1071 spec->init_verbs[0] = ad1986a_init_verbs;
1072 #ifdef CONFIG_SND_HDA_POWER_SAVE
1073 spec->loopback.amplist = ad1986a_loopbacks;
1075 spec->vmaster_nid = 0x1b;
1076 spec->inv_eapd = 1; /* AD1986A has the inverted EAPD implementation */
1078 codec->patch_ops = ad198x_patch_ops;
1080 /* override some parameters */
1081 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1084 switch (board_config) {
1085 case AD1986A_3STACK:
1086 spec->num_mixers = 2;
1087 spec->mixers[1] = ad1986a_3st_mixers;
1088 spec->num_init_verbs = 2;
1089 spec->init_verbs[1] = ad1986a_ch2_init;
1090 spec->channel_mode = ad1986a_modes;
1091 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1092 spec->need_dac_fix = 1;
1093 spec->multiout.max_channels = 2;
1094 spec->multiout.num_dacs = 1;
1096 case AD1986A_LAPTOP:
1097 spec->mixers[0] = ad1986a_laptop_mixers;
1098 spec->multiout.max_channels = 2;
1099 spec->multiout.num_dacs = 1;
1100 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1102 case AD1986A_LAPTOP_EAPD:
1103 spec->num_mixers = 3;
1104 spec->mixers[0] = ad1986a_laptop_master_mixers;
1105 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1106 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1107 spec->num_init_verbs = 2;
1108 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1109 spec->multiout.max_channels = 2;
1110 spec->multiout.num_dacs = 1;
1111 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1112 if (!is_jack_available(codec, 0x25))
1113 spec->multiout.dig_out_nid = 0;
1114 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1116 case AD1986A_SAMSUNG:
1117 spec->num_mixers = 2;
1118 spec->mixers[0] = ad1986a_laptop_master_mixers;
1119 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1120 spec->num_init_verbs = 3;
1121 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1122 spec->init_verbs[2] = ad1986a_automic_verbs;
1123 spec->multiout.max_channels = 2;
1124 spec->multiout.num_dacs = 1;
1125 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1126 if (!is_jack_available(codec, 0x25))
1127 spec->multiout.dig_out_nid = 0;
1128 spec->input_mux = &ad1986a_automic_capture_source;
1129 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1130 codec->patch_ops.init = ad1986a_automic_init;
1132 case AD1986A_SAMSUNG_P50:
1133 spec->num_mixers = 2;
1134 spec->mixers[0] = ad1986a_automute_master_mixers;
1135 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1136 spec->num_init_verbs = 4;
1137 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1138 spec->init_verbs[2] = ad1986a_automic_verbs;
1139 spec->init_verbs[3] = ad1986a_hp_init_verbs;
1140 spec->multiout.max_channels = 2;
1141 spec->multiout.num_dacs = 1;
1142 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1143 if (!is_jack_available(codec, 0x25))
1144 spec->multiout.dig_out_nid = 0;
1145 spec->input_mux = &ad1986a_automic_capture_source;
1146 codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event;
1147 codec->patch_ops.init = ad1986a_samsung_p50_init;
1149 case AD1986A_LAPTOP_AUTOMUTE:
1150 spec->num_mixers = 3;
1151 spec->mixers[0] = ad1986a_automute_master_mixers;
1152 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1153 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1154 spec->num_init_verbs = 3;
1155 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1156 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1157 spec->multiout.max_channels = 2;
1158 spec->multiout.num_dacs = 1;
1159 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1160 if (!is_jack_available(codec, 0x25))
1161 spec->multiout.dig_out_nid = 0;
1162 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1163 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1164 codec->patch_ops.init = ad1986a_hp_init;
1165 /* Lenovo N100 seems to report the reversed bit
1166 * for HP jack-sensing
1168 spec->inv_jack_detect = 1;
1171 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1172 spec->num_init_verbs = 2;
1173 spec->init_verbs[1] = ad1986a_ultra_init;
1174 spec->multiout.max_channels = 2;
1175 spec->multiout.num_dacs = 1;
1176 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1177 spec->multiout.dig_out_nid = 0;
1181 /* AD1986A has a hardware problem that it can't share a stream
1182 * with multiple output pins. The copy of front to surrounds
1183 * causes noisy or silent outputs at a certain timing, e.g.
1184 * changing the volume.
1185 * So, let's disable the shared stream.
1187 spec->multiout.no_share_stream = 1;
1189 codec->no_trigger_sense = 1;
1198 #define AD1983_SPDIF_OUT 0x02
1199 #define AD1983_DAC 0x03
1200 #define AD1983_ADC 0x04
1202 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1203 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1204 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1206 static struct hda_input_mux ad1983_capture_source = {
1212 { "Mix Mono", 0x3 },
1217 * SPDIF playback route
1219 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1221 static char *texts[] = { "PCM", "ADC" };
1223 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1225 uinfo->value.enumerated.items = 2;
1226 if (uinfo->value.enumerated.item > 1)
1227 uinfo->value.enumerated.item = 1;
1228 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1232 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1234 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1235 struct ad198x_spec *spec = codec->spec;
1237 ucontrol->value.enumerated.item[0] = spec->spdif_route;
1241 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1243 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1244 struct ad198x_spec *spec = codec->spec;
1246 if (ucontrol->value.enumerated.item[0] > 1)
1248 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1249 spec->spdif_route = ucontrol->value.enumerated.item[0];
1250 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1251 AC_VERB_SET_CONNECT_SEL,
1258 static struct snd_kcontrol_new ad1983_mixers[] = {
1259 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1260 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1261 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1262 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1263 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1264 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1265 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1266 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1267 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1268 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1269 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1270 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1271 HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1272 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1273 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1275 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1276 .name = "Capture Source",
1277 .info = ad198x_mux_enum_info,
1278 .get = ad198x_mux_enum_get,
1279 .put = ad198x_mux_enum_put,
1282 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1283 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1284 .info = ad1983_spdif_route_info,
1285 .get = ad1983_spdif_route_get,
1286 .put = ad1983_spdif_route_put,
1291 static struct hda_verb ad1983_init_verbs[] = {
1292 /* Front, HP, Mono; mute as default */
1293 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1294 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1295 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1296 /* Beep, PCM, Mic, Line-In: mute */
1297 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1298 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1299 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1300 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1301 /* Front, HP selectors; from Mix */
1302 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1303 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1304 /* Mono selector; from Mix */
1305 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1306 /* Mic selector; Mic */
1307 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1308 /* Line-in selector: Line-in */
1309 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1310 /* Mic boost: 0dB */
1311 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1312 /* Record selector: mic */
1313 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1314 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1315 /* SPDIF route: PCM */
1316 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1318 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1320 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1322 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1324 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1326 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1330 #ifdef CONFIG_SND_HDA_POWER_SAVE
1331 static struct hda_amp_list ad1983_loopbacks[] = {
1332 { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1333 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1338 static int patch_ad1983(struct hda_codec *codec)
1340 struct ad198x_spec *spec;
1343 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1349 err = snd_hda_attach_beep_device(codec, 0x10);
1354 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1356 spec->multiout.max_channels = 2;
1357 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1358 spec->multiout.dac_nids = ad1983_dac_nids;
1359 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1360 spec->num_adc_nids = 1;
1361 spec->adc_nids = ad1983_adc_nids;
1362 spec->capsrc_nids = ad1983_capsrc_nids;
1363 spec->input_mux = &ad1983_capture_source;
1364 spec->num_mixers = 1;
1365 spec->mixers[0] = ad1983_mixers;
1366 spec->num_init_verbs = 1;
1367 spec->init_verbs[0] = ad1983_init_verbs;
1368 spec->spdif_route = 0;
1369 #ifdef CONFIG_SND_HDA_POWER_SAVE
1370 spec->loopback.amplist = ad1983_loopbacks;
1372 spec->vmaster_nid = 0x05;
1374 codec->patch_ops = ad198x_patch_ops;
1376 codec->no_trigger_sense = 1;
1383 * AD1981 HD specific
1386 #define AD1981_SPDIF_OUT 0x02
1387 #define AD1981_DAC 0x03
1388 #define AD1981_ADC 0x04
1390 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1391 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1392 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1394 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1395 static struct hda_input_mux ad1981_capture_source = {
1398 { "Front Mic", 0x0 },
1401 { "Mix Mono", 0x3 },
1408 static struct snd_kcontrol_new ad1981_mixers[] = {
1409 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1410 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1411 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1412 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1413 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1414 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1415 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1416 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1417 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1418 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1419 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1420 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1421 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1422 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1423 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1424 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1425 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1426 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1427 HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1428 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
1429 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1430 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1432 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1433 .name = "Capture Source",
1434 .info = ad198x_mux_enum_info,
1435 .get = ad198x_mux_enum_get,
1436 .put = ad198x_mux_enum_put,
1438 /* identical with AD1983 */
1440 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1441 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1442 .info = ad1983_spdif_route_info,
1443 .get = ad1983_spdif_route_get,
1444 .put = ad1983_spdif_route_put,
1449 static struct hda_verb ad1981_init_verbs[] = {
1450 /* Front, HP, Mono; mute as default */
1451 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1452 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1453 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1454 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1455 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1456 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1457 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1458 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1459 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1460 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1461 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1462 /* Front, HP selectors; from Mix */
1463 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1464 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1465 /* Mono selector; from Mix */
1466 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1467 /* Mic Mixer; select Front Mic */
1468 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1469 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1470 /* Mic boost: 0dB */
1471 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1472 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1473 /* Record selector: Front mic */
1474 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1475 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1476 /* SPDIF route: PCM */
1477 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1479 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1481 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1483 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1484 /* Front & Rear Mic Pins */
1485 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1486 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1488 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1490 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1491 /* Line-Out as Input: disabled */
1492 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1496 #ifdef CONFIG_SND_HDA_POWER_SAVE
1497 static struct hda_amp_list ad1981_loopbacks[] = {
1498 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1499 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1500 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1501 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1502 { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1508 * Patch for HP nx6320
1510 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1511 * speaker output enabled _and_ mute-LED off.
1514 #define AD1981_HP_EVENT 0x37
1515 #define AD1981_MIC_EVENT 0x38
1517 static struct hda_verb ad1981_hp_init_verbs[] = {
1518 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1519 /* pin sensing on HP and Mic jacks */
1520 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1521 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1525 /* turn on/off EAPD (+ mute HP) as a master switch */
1526 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1527 struct snd_ctl_elem_value *ucontrol)
1529 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1530 struct ad198x_spec *spec = codec->spec;
1532 if (! ad198x_eapd_put(kcontrol, ucontrol))
1534 /* change speaker pin appropriately */
1535 snd_hda_codec_write(codec, 0x05, 0,
1536 AC_VERB_SET_PIN_WIDGET_CONTROL,
1537 spec->cur_eapd ? PIN_OUT : 0);
1538 /* toggle HP mute appropriately */
1539 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1541 spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1545 /* bind volumes of both NID 0x05 and 0x06 */
1546 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1547 .ops = &snd_hda_bind_vol,
1549 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1550 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1555 /* mute internal speaker if HP is plugged */
1556 static void ad1981_hp_automute(struct hda_codec *codec)
1558 unsigned int present;
1560 present = snd_hda_jack_detect(codec, 0x06);
1561 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1562 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1565 /* toggle input of built-in and mic jack appropriately */
1566 static void ad1981_hp_automic(struct hda_codec *codec)
1568 static struct hda_verb mic_jack_on[] = {
1569 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1570 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1573 static struct hda_verb mic_jack_off[] = {
1574 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1575 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1578 unsigned int present;
1580 present = snd_hda_jack_detect(codec, 0x08);
1582 snd_hda_sequence_write(codec, mic_jack_on);
1584 snd_hda_sequence_write(codec, mic_jack_off);
1587 /* unsolicited event for HP jack sensing */
1588 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1593 case AD1981_HP_EVENT:
1594 ad1981_hp_automute(codec);
1596 case AD1981_MIC_EVENT:
1597 ad1981_hp_automic(codec);
1602 static struct hda_input_mux ad1981_hp_capture_source = {
1606 { "Docking-Station", 0x1 },
1611 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1612 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1614 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1615 .name = "Master Playback Switch",
1616 .info = ad198x_eapd_info,
1617 .get = ad198x_eapd_get,
1618 .put = ad1981_hp_master_sw_put,
1619 .private_value = 0x05,
1621 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1622 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1624 /* FIXME: analog mic/line loopback doesn't work with my tests...
1625 * (although recording is OK)
1627 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1628 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1629 HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1630 HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1631 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1632 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1633 /* FIXME: does this laptop have analog CD connection? */
1634 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1635 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1637 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1638 HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1639 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1640 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1642 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1643 .name = "Capture Source",
1644 .info = ad198x_mux_enum_info,
1645 .get = ad198x_mux_enum_get,
1646 .put = ad198x_mux_enum_put,
1651 /* initialize jack-sensing, too */
1652 static int ad1981_hp_init(struct hda_codec *codec)
1655 ad1981_hp_automute(codec);
1656 ad1981_hp_automic(codec);
1660 /* configuration for Toshiba Laptops */
1661 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1662 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1663 /* pin sensing on HP and Mic jacks */
1664 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1665 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1669 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1670 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1671 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1675 /* configuration for Lenovo Thinkpad T60 */
1676 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1677 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1678 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1679 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1680 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1681 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1682 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1683 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1684 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1685 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1686 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1687 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1690 .name = "Capture Source",
1691 .info = ad198x_mux_enum_info,
1692 .get = ad198x_mux_enum_get,
1693 .put = ad198x_mux_enum_put,
1695 /* identical with AD1983 */
1697 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1698 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1699 .info = ad1983_spdif_route_info,
1700 .get = ad1983_spdif_route_get,
1701 .put = ad1983_spdif_route_put,
1706 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1724 static const char *ad1981_models[AD1981_MODELS] = {
1726 [AD1981_THINKPAD] = "thinkpad",
1727 [AD1981_BASIC] = "basic",
1728 [AD1981_TOSHIBA] = "toshiba"
1731 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1732 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1733 SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
1735 SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP),
1736 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1737 /* Lenovo Thinkpad T60/X60/Z6xx */
1738 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD),
1739 /* HP nx6320 (reversed SSID, H/W bug) */
1740 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1744 static int patch_ad1981(struct hda_codec *codec)
1746 struct ad198x_spec *spec;
1747 int err, board_config;
1749 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1755 err = snd_hda_attach_beep_device(codec, 0x10);
1760 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
1762 spec->multiout.max_channels = 2;
1763 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1764 spec->multiout.dac_nids = ad1981_dac_nids;
1765 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1766 spec->num_adc_nids = 1;
1767 spec->adc_nids = ad1981_adc_nids;
1768 spec->capsrc_nids = ad1981_capsrc_nids;
1769 spec->input_mux = &ad1981_capture_source;
1770 spec->num_mixers = 1;
1771 spec->mixers[0] = ad1981_mixers;
1772 spec->num_init_verbs = 1;
1773 spec->init_verbs[0] = ad1981_init_verbs;
1774 spec->spdif_route = 0;
1775 #ifdef CONFIG_SND_HDA_POWER_SAVE
1776 spec->loopback.amplist = ad1981_loopbacks;
1778 spec->vmaster_nid = 0x05;
1780 codec->patch_ops = ad198x_patch_ops;
1782 /* override some parameters */
1783 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1786 switch (board_config) {
1788 spec->mixers[0] = ad1981_hp_mixers;
1789 spec->num_init_verbs = 2;
1790 spec->init_verbs[1] = ad1981_hp_init_verbs;
1791 spec->multiout.dig_out_nid = 0;
1792 spec->input_mux = &ad1981_hp_capture_source;
1794 codec->patch_ops.init = ad1981_hp_init;
1795 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1796 /* set the upper-limit for mixer amp to 0dB for avoiding the
1797 * possible damage by overloading
1799 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
1800 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
1801 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
1802 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
1803 (1 << AC_AMPCAP_MUTE_SHIFT));
1805 case AD1981_THINKPAD:
1806 spec->mixers[0] = ad1981_thinkpad_mixers;
1807 spec->input_mux = &ad1981_thinkpad_capture_source;
1809 case AD1981_TOSHIBA:
1810 spec->mixers[0] = ad1981_hp_mixers;
1811 spec->mixers[1] = ad1981_toshiba_mixers;
1812 spec->num_init_verbs = 2;
1813 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1814 spec->multiout.dig_out_nid = 0;
1815 spec->input_mux = &ad1981_hp_capture_source;
1816 codec->patch_ops.init = ad1981_hp_init;
1817 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1821 codec->no_trigger_sense = 1;
1830 * Output pins and routes
1832 * Pin Mix Sel DAC (*)
1833 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1834 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1835 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
1836 * port-D 0x12 (mute/hp) <- 0x29 <- 04
1837 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1838 * port-F 0x16 (mute) <- 0x2a <- 06
1839 * port-G 0x24 (mute) <- 0x27 <- 05
1840 * port-H 0x25 (mute) <- 0x28 <- 0a
1841 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1843 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1844 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1846 * Input pins and routes
1848 * pin boost mix input # / adc input #
1849 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1850 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1851 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1852 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1853 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1854 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1855 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1856 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1860 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1861 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1863 * Inputs of Analog Mix (0x20)
1864 * 0:Port-B (front mic)
1865 * 1:Port-C/G/H (line-in)
1867 * 3:Port-D (line-in/2)
1868 * 4:Port-E/G/H (mic-in)
1869 * 5:Port-F (mic2-in)
1875 * 1:Port-B (front mic-in)
1876 * 2:Port-C (line-in)
1877 * 3:Port-F (mic2-in)
1882 * 8:Port-D (line-in/2)
1885 * Proposed pin assignments by the datasheet
1888 * Port-A front headphone
1898 * Port-A front headphone
1900 * C rear line-in/surround
1902 * E rear mic-in/CLFE
1908 * D internal speaker (with EAPD)
1909 * E/F quad mic array
1925 /* reivision id to check workarounds */
1926 #define AD1988A_REV2 0x100200
1928 #define is_rev2(codec) \
1929 ((codec)->vendor_id == 0x11d41988 && \
1930 (codec)->revision_id == AD1988A_REV2)
1936 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1937 0x04, 0x06, 0x05, 0x0a
1940 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1944 /* for AD1988A revision-2, DAC2-4 are swapped */
1945 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1946 0x04, 0x05, 0x0a, 0x06
1949 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1953 static hda_nid_t ad1988_adc_nids[3] = {
1957 static hda_nid_t ad1988_capsrc_nids[3] = {
1961 #define AD1988_SPDIF_OUT 0x02
1962 #define AD1988_SPDIF_OUT_HDMI 0x0b
1963 #define AD1988_SPDIF_IN 0x07
1965 static hda_nid_t ad1989b_slave_dig_outs[] = {
1966 AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
1969 static struct hda_input_mux ad1988_6stack_capture_source = {
1972 { "Front Mic", 0x1 }, /* port-B */
1973 { "Line", 0x2 }, /* port-C */
1974 { "Mic", 0x4 }, /* port-E */
1980 static struct hda_input_mux ad1988_laptop_capture_source = {
1983 { "Mic/Line", 0x1 }, /* port-B */
1991 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1992 struct snd_ctl_elem_info *uinfo)
1994 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1995 struct ad198x_spec *spec = codec->spec;
1996 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1997 spec->num_channel_mode);
2000 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
2001 struct snd_ctl_elem_value *ucontrol)
2003 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2004 struct ad198x_spec *spec = codec->spec;
2005 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
2006 spec->num_channel_mode, spec->multiout.max_channels);
2009 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
2010 struct snd_ctl_elem_value *ucontrol)
2012 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2013 struct ad198x_spec *spec = codec->spec;
2014 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
2015 spec->num_channel_mode,
2016 &spec->multiout.max_channels);
2017 if (err >= 0 && spec->need_dac_fix)
2018 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2023 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
2024 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2025 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2026 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2027 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2028 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2032 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
2033 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2034 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2035 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2036 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
2037 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2041 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
2042 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2043 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
2044 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
2045 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
2046 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
2047 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2048 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2050 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2051 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2052 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2053 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2054 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2055 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2056 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2057 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2059 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2060 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2062 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2063 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2069 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
2070 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2071 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2072 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2073 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2077 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
2078 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2079 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2080 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
2081 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
2085 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
2086 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2087 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
2088 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
2089 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
2090 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2091 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2093 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2094 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2095 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2096 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2097 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2098 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2099 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2100 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2102 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2103 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2105 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2106 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2108 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2109 .name = "Channel Mode",
2110 .info = ad198x_ch_mode_info,
2111 .get = ad198x_ch_mode_get,
2112 .put = ad198x_ch_mode_put,
2119 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
2120 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2121 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
2122 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2124 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2125 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2126 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2127 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2128 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2129 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2131 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2132 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2134 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2138 .name = "External Amplifier",
2139 .info = ad198x_eapd_info,
2140 .get = ad198x_eapd_get,
2141 .put = ad198x_eapd_put,
2142 .private_value = 0x12, /* port-D */
2149 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2150 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2151 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2152 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2153 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2154 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2155 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2157 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2158 /* The multiple "Capture Source" controls confuse alsamixer
2159 * So call somewhat different..
2161 /* .name = "Capture Source", */
2162 .name = "Input Source",
2164 .info = ad198x_mux_enum_info,
2165 .get = ad198x_mux_enum_get,
2166 .put = ad198x_mux_enum_put,
2171 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2172 struct snd_ctl_elem_info *uinfo)
2174 static char *texts[] = {
2175 "PCM", "ADC1", "ADC2", "ADC3"
2177 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2179 uinfo->value.enumerated.items = 4;
2180 if (uinfo->value.enumerated.item >= 4)
2181 uinfo->value.enumerated.item = 3;
2182 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2186 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2187 struct snd_ctl_elem_value *ucontrol)
2189 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2192 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2195 ucontrol->value.enumerated.item[0] = 0;
2197 sel = snd_hda_codec_read(codec, 0x0b, 0,
2198 AC_VERB_GET_CONNECT_SEL, 0);
2203 ucontrol->value.enumerated.item[0] = sel;
2208 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2209 struct snd_ctl_elem_value *ucontrol)
2211 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2212 unsigned int val, sel;
2215 val = ucontrol->value.enumerated.item[0];
2219 sel = snd_hda_codec_read(codec, 0x1d, 0,
2220 AC_VERB_GET_AMP_GAIN_MUTE,
2222 change = sel & 0x80;
2224 snd_hda_codec_write_cache(codec, 0x1d, 0,
2225 AC_VERB_SET_AMP_GAIN_MUTE,
2227 snd_hda_codec_write_cache(codec, 0x1d, 0,
2228 AC_VERB_SET_AMP_GAIN_MUTE,
2232 sel = snd_hda_codec_read(codec, 0x1d, 0,
2233 AC_VERB_GET_AMP_GAIN_MUTE,
2234 AC_AMP_GET_INPUT | 0x01);
2235 change = sel & 0x80;
2237 snd_hda_codec_write_cache(codec, 0x1d, 0,
2238 AC_VERB_SET_AMP_GAIN_MUTE,
2240 snd_hda_codec_write_cache(codec, 0x1d, 0,
2241 AC_VERB_SET_AMP_GAIN_MUTE,
2244 sel = snd_hda_codec_read(codec, 0x0b, 0,
2245 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2246 change |= sel != val;
2248 snd_hda_codec_write_cache(codec, 0x0b, 0,
2249 AC_VERB_SET_CONNECT_SEL,
2255 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2256 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2258 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2259 .name = "IEC958 Playback Source",
2260 .info = ad1988_spdif_playback_source_info,
2261 .get = ad1988_spdif_playback_source_get,
2262 .put = ad1988_spdif_playback_source_put,
2267 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2268 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2272 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2273 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2274 HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2279 * initialization verbs
2283 * for 6-stack (+dig)
2285 static struct hda_verb ad1988_6stack_init_verbs[] = {
2286 /* Front, Surround, CLFE, side DAC; unmute as default */
2287 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2288 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2289 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2290 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2291 /* Port-A front headphon path */
2292 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2293 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2294 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2295 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2296 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2297 /* Port-D line-out path */
2298 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2299 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2300 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2301 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2302 /* Port-F surround path */
2303 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2304 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2305 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2306 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2307 /* Port-G CLFE path */
2308 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2309 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2310 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2311 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2312 /* Port-H side path */
2313 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2314 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2315 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2316 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2318 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2319 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2320 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2321 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2322 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2323 /* Port-B front mic-in path */
2324 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2325 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2326 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2327 /* Port-C line-in path */
2328 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2329 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2330 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2331 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2332 /* Port-E mic-in path */
2333 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2334 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2335 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2336 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2337 /* Analog CD Input */
2338 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2339 /* Analog Mix output amp */
2340 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2345 static struct hda_verb ad1988_capture_init_verbs[] = {
2346 /* mute analog mix */
2347 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2348 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2349 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2350 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2351 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2352 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2353 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2354 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2355 /* select ADCs - front-mic */
2356 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2357 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2358 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2363 static struct hda_verb ad1988_spdif_init_verbs[] = {
2365 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2366 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2367 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2368 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2370 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2375 /* AD1989 has no ADC -> SPDIF route */
2376 static struct hda_verb ad1989_spdif_init_verbs[] = {
2377 /* SPDIF-1 out pin */
2378 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2379 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2380 /* SPDIF-2/HDMI out pin */
2381 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2382 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2387 * verbs for 3stack (+dig)
2389 static struct hda_verb ad1988_3stack_ch2_init[] = {
2390 /* set port-C to line-in */
2391 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2392 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2393 /* set port-E to mic-in */
2394 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2395 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2399 static struct hda_verb ad1988_3stack_ch6_init[] = {
2400 /* set port-C to surround out */
2401 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2402 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2403 /* set port-E to CLFE out */
2404 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2405 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2409 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2410 { 2, ad1988_3stack_ch2_init },
2411 { 6, ad1988_3stack_ch6_init },
2414 static struct hda_verb ad1988_3stack_init_verbs[] = {
2415 /* Front, Surround, CLFE, side DAC; unmute as default */
2416 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2417 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2418 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2419 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2420 /* Port-A front headphon path */
2421 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2422 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2423 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2424 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2425 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2426 /* Port-D line-out path */
2427 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2428 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2429 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2430 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2432 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2433 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2434 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2435 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2436 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2437 /* Port-B front mic-in path */
2438 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2439 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2440 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2441 /* Port-C line-in/surround path - 6ch mode as default */
2442 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2443 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2444 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2445 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2446 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2447 /* Port-E mic-in/CLFE path - 6ch mode as default */
2448 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2449 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2450 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2451 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2452 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2453 /* mute analog mix */
2454 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2455 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2456 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2457 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2458 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2459 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2460 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2461 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2462 /* select ADCs - front-mic */
2463 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2464 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2465 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2466 /* Analog Mix output amp */
2467 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2472 * verbs for laptop mode (+dig)
2474 static struct hda_verb ad1988_laptop_hp_on[] = {
2475 /* unmute port-A and mute port-D */
2476 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2477 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2480 static struct hda_verb ad1988_laptop_hp_off[] = {
2481 /* mute port-A and unmute port-D */
2482 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2483 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2487 #define AD1988_HP_EVENT 0x01
2489 static struct hda_verb ad1988_laptop_init_verbs[] = {
2490 /* Front, Surround, CLFE, side DAC; unmute as default */
2491 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2492 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2493 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2494 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2495 /* Port-A front headphon path */
2496 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2497 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2498 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2499 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2500 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2501 /* unsolicited event for pin-sense */
2502 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2503 /* Port-D line-out path + EAPD */
2504 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2505 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2506 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2507 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2508 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2510 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2511 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2512 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2513 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2514 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2515 /* Port-B mic-in path */
2516 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2517 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2518 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2519 /* Port-C docking station - try to output */
2520 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2521 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2522 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2523 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2524 /* mute analog mix */
2525 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2526 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2527 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2528 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2529 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2530 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2531 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2532 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2533 /* select ADCs - mic */
2534 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2535 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2536 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2537 /* Analog Mix output amp */
2538 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2542 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2544 if ((res >> 26) != AD1988_HP_EVENT)
2546 if (snd_hda_jack_detect(codec, 0x11))
2547 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2549 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2552 #ifdef CONFIG_SND_HDA_POWER_SAVE
2553 static struct hda_amp_list ad1988_loopbacks[] = {
2554 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2555 { 0x20, HDA_INPUT, 1 }, /* Line */
2556 { 0x20, HDA_INPUT, 4 }, /* Mic */
2557 { 0x20, HDA_INPUT, 6 }, /* CD */
2563 * Automatic parse of I/O pins from the BIOS configuration
2571 static struct snd_kcontrol_new ad1988_control_templates[] = {
2572 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2573 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2574 HDA_BIND_MUTE(NULL, 0, 0, 0),
2577 /* add dynamic controls */
2578 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2581 struct snd_kcontrol_new *knew;
2583 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2584 knew = snd_array_new(&spec->kctls);
2587 *knew = ad1988_control_templates[type];
2588 knew->name = kstrdup(name, GFP_KERNEL);
2591 if (get_amp_nid_(val))
2592 knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val);
2593 knew->private_value = val;
2597 #define AD1988_PIN_CD_NID 0x18
2598 #define AD1988_PIN_BEEP_NID 0x10
2600 static hda_nid_t ad1988_mixer_nids[8] = {
2601 /* A B C D E F G H */
2602 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2605 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2607 static hda_nid_t idx_to_dac[8] = {
2608 /* A B C D E F G H */
2609 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2611 static hda_nid_t idx_to_dac_rev2[8] = {
2612 /* A B C D E F G H */
2613 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2616 return idx_to_dac_rev2[idx];
2618 return idx_to_dac[idx];
2621 static hda_nid_t ad1988_boost_nids[8] = {
2622 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2625 static int ad1988_pin_idx(hda_nid_t nid)
2627 static hda_nid_t ad1988_io_pins[8] = {
2628 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2631 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2632 if (ad1988_io_pins[i] == nid)
2634 return 0; /* should be -1 */
2637 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2639 static int loopback_idx[8] = {
2640 2, 0, 1, 3, 4, 5, 1, 4
2643 case AD1988_PIN_CD_NID:
2646 return loopback_idx[ad1988_pin_idx(nid)];
2650 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2652 static int adc_idx[8] = {
2653 0, 1, 2, 8, 4, 3, 6, 7
2656 case AD1988_PIN_CD_NID:
2659 return adc_idx[ad1988_pin_idx(nid)];
2663 /* fill in the dac_nids table from the parsed pin configuration */
2664 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2665 const struct auto_pin_cfg *cfg)
2667 struct ad198x_spec *spec = codec->spec;
2670 spec->multiout.dac_nids = spec->private_dac_nids;
2672 /* check the pins hardwired to audio widget */
2673 for (i = 0; i < cfg->line_outs; i++) {
2674 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2675 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2677 spec->multiout.num_dacs = cfg->line_outs;
2681 /* add playback controls from the parsed DAC table */
2682 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2683 const struct auto_pin_cfg *cfg)
2686 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2690 for (i = 0; i < cfg->line_outs; i++) {
2691 hda_nid_t dac = spec->multiout.dac_nids[i];
2694 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2697 err = add_control(spec, AD_CTL_WIDGET_VOL,
2698 "Center Playback Volume",
2699 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2702 err = add_control(spec, AD_CTL_WIDGET_VOL,
2703 "LFE Playback Volume",
2704 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2707 err = add_control(spec, AD_CTL_BIND_MUTE,
2708 "Center Playback Switch",
2709 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2712 err = add_control(spec, AD_CTL_BIND_MUTE,
2713 "LFE Playback Switch",
2714 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2718 sprintf(name, "%s Playback Volume", chname[i]);
2719 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2720 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2723 sprintf(name, "%s Playback Switch", chname[i]);
2724 err = add_control(spec, AD_CTL_BIND_MUTE, name,
2725 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2733 /* add playback controls for speaker and HP outputs */
2734 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2737 struct ad198x_spec *spec = codec->spec;
2745 idx = ad1988_pin_idx(pin);
2746 nid = ad1988_idx_to_dac(codec, idx);
2747 /* check whether the corresponding DAC was already taken */
2748 for (i = 0; i < spec->autocfg.line_outs; i++) {
2749 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2750 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2754 if (i >= spec->autocfg.line_outs) {
2755 /* specify the DAC as the extra output */
2756 if (!spec->multiout.hp_nid)
2757 spec->multiout.hp_nid = nid;
2759 spec->multiout.extra_out_nid[0] = nid;
2760 /* control HP volume/switch on the output mixer amp */
2761 sprintf(name, "%s Playback Volume", pfx);
2762 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2763 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2767 nid = ad1988_mixer_nids[idx];
2768 sprintf(name, "%s Playback Switch", pfx);
2769 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2770 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2775 /* create input playback/capture controls for the given pin */
2776 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2777 const char *ctlname, int boost)
2782 sprintf(name, "%s Playback Volume", ctlname);
2783 idx = ad1988_pin_to_loopback_idx(pin);
2784 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2785 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2787 sprintf(name, "%s Playback Switch", ctlname);
2788 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2789 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2793 idx = ad1988_pin_idx(pin);
2794 bnid = ad1988_boost_nids[idx];
2796 sprintf(name, "%s Boost", ctlname);
2797 return add_control(spec, AD_CTL_WIDGET_VOL, name,
2798 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2805 /* create playback/capture controls for input pins */
2806 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2807 const struct auto_pin_cfg *cfg)
2809 struct hda_input_mux *imux = &spec->private_imux;
2812 for (i = 0; i < AUTO_PIN_LAST; i++) {
2813 err = new_analog_input(spec, cfg->input_pins[i],
2814 auto_pin_cfg_labels[i],
2815 i <= AUTO_PIN_FRONT_MIC);
2818 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2819 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2822 imux->items[imux->num_items].label = "Mix";
2823 imux->items[imux->num_items].index = 9;
2826 if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2827 "Analog Mix Playback Volume",
2828 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2830 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2831 "Analog Mix Playback Switch",
2832 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2838 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2839 hda_nid_t nid, int pin_type,
2843 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2844 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2846 case 0x11: /* port-A - DAC 04 */
2847 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2849 case 0x14: /* port-B - DAC 06 */
2850 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2852 case 0x15: /* port-C - DAC 05 */
2853 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2855 case 0x17: /* port-E - DAC 0a */
2856 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2858 case 0x13: /* mono - DAC 04 */
2859 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2864 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2866 struct ad198x_spec *spec = codec->spec;
2869 for (i = 0; i < spec->autocfg.line_outs; i++) {
2870 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2871 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2875 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2877 struct ad198x_spec *spec = codec->spec;
2880 pin = spec->autocfg.speaker_pins[0];
2881 if (pin) /* connect to front */
2882 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2883 pin = spec->autocfg.hp_pins[0];
2884 if (pin) /* connect to front */
2885 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2888 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2890 struct ad198x_spec *spec = codec->spec;
2893 for (i = 0; i < AUTO_PIN_LAST; i++) {
2894 hda_nid_t nid = spec->autocfg.input_pins[i];
2898 case 0x15: /* port-C */
2899 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2901 case 0x17: /* port-E */
2902 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2905 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2906 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2907 if (nid != AD1988_PIN_CD_NID)
2908 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2910 idx = ad1988_pin_idx(nid);
2911 if (ad1988_boost_nids[idx])
2912 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2913 AC_VERB_SET_AMP_GAIN_MUTE,
2918 /* parse the BIOS configuration and set up the alc_spec */
2919 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2920 static int ad1988_parse_auto_config(struct hda_codec *codec)
2922 struct ad198x_spec *spec = codec->spec;
2925 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2927 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2929 if (! spec->autocfg.line_outs)
2930 return 0; /* can't find valid BIOS pin config */
2931 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2932 (err = ad1988_auto_create_extra_out(codec,
2933 spec->autocfg.speaker_pins[0],
2935 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2936 "Headphone")) < 0 ||
2937 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2940 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2942 if (spec->autocfg.dig_outs)
2943 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2944 if (spec->autocfg.dig_in_pin)
2945 spec->dig_in_nid = AD1988_SPDIF_IN;
2947 if (spec->kctls.list)
2948 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2950 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2952 spec->input_mux = &spec->private_imux;
2957 /* init callback for auto-configuration model -- overriding the default init */
2958 static int ad1988_auto_init(struct hda_codec *codec)
2961 ad1988_auto_init_multi_out(codec);
2962 ad1988_auto_init_extra_out(codec);
2963 ad1988_auto_init_analog_input(codec);
2971 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2972 [AD1988_6STACK] = "6stack",
2973 [AD1988_6STACK_DIG] = "6stack-dig",
2974 [AD1988_3STACK] = "3stack",
2975 [AD1988_3STACK_DIG] = "3stack-dig",
2976 [AD1988_LAPTOP] = "laptop",
2977 [AD1988_LAPTOP_DIG] = "laptop-dig",
2978 [AD1988_AUTO] = "auto",
2981 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2982 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2983 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2984 SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
2985 SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
2989 static int patch_ad1988(struct hda_codec *codec)
2991 struct ad198x_spec *spec;
2992 int err, board_config;
2994 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3001 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
3003 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
3004 ad1988_models, ad1988_cfg_tbl);
3005 if (board_config < 0) {
3006 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3008 board_config = AD1988_AUTO;
3011 if (board_config == AD1988_AUTO) {
3012 /* automatic parse from the BIOS config */
3013 err = ad1988_parse_auto_config(codec);
3018 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n");
3019 board_config = AD1988_6STACK;
3023 err = snd_hda_attach_beep_device(codec, 0x10);
3028 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3030 switch (board_config) {
3032 case AD1988_6STACK_DIG:
3033 spec->multiout.max_channels = 8;
3034 spec->multiout.num_dacs = 4;
3036 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
3038 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
3039 spec->input_mux = &ad1988_6stack_capture_source;
3040 spec->num_mixers = 2;
3042 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
3044 spec->mixers[0] = ad1988_6stack_mixers1;
3045 spec->mixers[1] = ad1988_6stack_mixers2;
3046 spec->num_init_verbs = 1;
3047 spec->init_verbs[0] = ad1988_6stack_init_verbs;
3048 if (board_config == AD1988_6STACK_DIG) {
3049 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3050 spec->dig_in_nid = AD1988_SPDIF_IN;
3054 case AD1988_3STACK_DIG:
3055 spec->multiout.max_channels = 6;
3056 spec->multiout.num_dacs = 3;
3058 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
3060 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3061 spec->input_mux = &ad1988_6stack_capture_source;
3062 spec->channel_mode = ad1988_3stack_modes;
3063 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
3064 spec->num_mixers = 2;
3066 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
3068 spec->mixers[0] = ad1988_3stack_mixers1;
3069 spec->mixers[1] = ad1988_3stack_mixers2;
3070 spec->num_init_verbs = 1;
3071 spec->init_verbs[0] = ad1988_3stack_init_verbs;
3072 if (board_config == AD1988_3STACK_DIG)
3073 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3076 case AD1988_LAPTOP_DIG:
3077 spec->multiout.max_channels = 2;
3078 spec->multiout.num_dacs = 1;
3079 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3080 spec->input_mux = &ad1988_laptop_capture_source;
3081 spec->num_mixers = 1;
3082 spec->mixers[0] = ad1988_laptop_mixers;
3083 spec->inv_eapd = 1; /* inverted EAPD */
3084 spec->num_init_verbs = 1;
3085 spec->init_verbs[0] = ad1988_laptop_init_verbs;
3086 if (board_config == AD1988_LAPTOP_DIG)
3087 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3091 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
3092 spec->adc_nids = ad1988_adc_nids;
3093 spec->capsrc_nids = ad1988_capsrc_nids;
3094 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
3095 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
3096 if (spec->multiout.dig_out_nid) {
3097 if (codec->vendor_id >= 0x11d4989a) {
3098 spec->mixers[spec->num_mixers++] =
3099 ad1989_spdif_out_mixers;
3100 spec->init_verbs[spec->num_init_verbs++] =
3101 ad1989_spdif_init_verbs;
3102 codec->slave_dig_outs = ad1989b_slave_dig_outs;
3104 spec->mixers[spec->num_mixers++] =
3105 ad1988_spdif_out_mixers;
3106 spec->init_verbs[spec->num_init_verbs++] =
3107 ad1988_spdif_init_verbs;
3110 if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a)
3111 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
3113 codec->patch_ops = ad198x_patch_ops;
3114 switch (board_config) {
3116 codec->patch_ops.init = ad1988_auto_init;
3119 case AD1988_LAPTOP_DIG:
3120 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
3123 #ifdef CONFIG_SND_HDA_POWER_SAVE
3124 spec->loopback.amplist = ad1988_loopbacks;
3126 spec->vmaster_nid = 0x04;
3128 codec->no_trigger_sense = 1;
3137 * port-B - front line/mic-in
3138 * port-E - aux in/out
3139 * port-F - aux in/out
3140 * port-C - rear line/mic-in
3141 * port-D - rear line/hp-out
3142 * port-A - front line/hp-out
3144 * AD1984 = AD1884 + two digital mic-ins
3147 * For simplicity, we share the single DAC for both HP and line-outs
3148 * right now. The inidividual playbacks could be easily implemented,
3149 * but no build-up framework is given, so far.
3152 static hda_nid_t ad1884_dac_nids[1] = {
3156 static hda_nid_t ad1884_adc_nids[2] = {
3160 static hda_nid_t ad1884_capsrc_nids[2] = {
3164 #define AD1884_SPDIF_OUT 0x02
3166 static struct hda_input_mux ad1884_capture_source = {
3169 { "Front Mic", 0x0 },
3176 static struct snd_kcontrol_new ad1884_base_mixers[] = {
3177 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3178 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3179 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3180 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3181 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3182 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3183 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3184 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3185 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3186 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3187 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3188 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3189 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3190 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3191 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3192 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3193 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3194 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3196 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3197 /* The multiple "Capture Source" controls confuse alsamixer
3198 * So call somewhat different..
3200 /* .name = "Capture Source", */
3201 .name = "Input Source",
3203 .info = ad198x_mux_enum_info,
3204 .get = ad198x_mux_enum_get,
3205 .put = ad198x_mux_enum_put,
3207 /* SPDIF controls */
3208 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3210 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3211 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3212 /* identical with ad1983 */
3213 .info = ad1983_spdif_route_info,
3214 .get = ad1983_spdif_route_get,
3215 .put = ad1983_spdif_route_put,
3220 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3221 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3222 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3223 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3225 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3231 * initialization verbs
3233 static struct hda_verb ad1884_init_verbs[] = {
3234 /* DACs; mute as default */
3235 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3236 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3237 /* Port-A (HP) mixer */
3238 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3239 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3241 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3242 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3243 /* HP selector - select DAC2 */
3244 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3245 /* Port-D (Line-out) mixer */
3246 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3247 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3249 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3250 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3251 /* Mono-out mixer */
3252 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3253 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3255 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3256 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3258 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3259 /* Port-B (front mic) pin */
3260 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3261 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3262 /* Port-C (rear mic) pin */
3263 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3264 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3265 /* Analog mixer; mute as default */
3266 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3267 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3268 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3269 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3270 /* Analog Mix output amp */
3271 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3272 /* SPDIF output selector */
3273 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3274 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3278 #ifdef CONFIG_SND_HDA_POWER_SAVE
3279 static struct hda_amp_list ad1884_loopbacks[] = {
3280 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3281 { 0x20, HDA_INPUT, 1 }, /* Mic */
3282 { 0x20, HDA_INPUT, 2 }, /* CD */
3283 { 0x20, HDA_INPUT, 4 }, /* Docking */
3288 static const char *ad1884_slave_vols[] = {
3289 "PCM Playback Volume",
3290 "Mic Playback Volume",
3291 "Mono Playback Volume",
3292 "Front Mic Playback Volume",
3293 "Mic Playback Volume",
3294 "CD Playback Volume",
3295 "Internal Mic Playback Volume",
3296 "Docking Mic Playback Volume",
3297 /* "Beep Playback Volume", */
3298 "IEC958 Playback Volume",
3302 static int patch_ad1884(struct hda_codec *codec)
3304 struct ad198x_spec *spec;
3307 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3313 err = snd_hda_attach_beep_device(codec, 0x10);
3318 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3320 spec->multiout.max_channels = 2;
3321 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3322 spec->multiout.dac_nids = ad1884_dac_nids;
3323 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3324 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3325 spec->adc_nids = ad1884_adc_nids;
3326 spec->capsrc_nids = ad1884_capsrc_nids;
3327 spec->input_mux = &ad1884_capture_source;
3328 spec->num_mixers = 1;
3329 spec->mixers[0] = ad1884_base_mixers;
3330 spec->num_init_verbs = 1;
3331 spec->init_verbs[0] = ad1884_init_verbs;
3332 spec->spdif_route = 0;
3333 #ifdef CONFIG_SND_HDA_POWER_SAVE
3334 spec->loopback.amplist = ad1884_loopbacks;
3336 spec->vmaster_nid = 0x04;
3337 /* we need to cover all playback volumes */
3338 spec->slave_vols = ad1884_slave_vols;
3340 codec->patch_ops = ad198x_patch_ops;
3342 codec->no_trigger_sense = 1;
3348 * Lenovo Thinkpad T61/X61
3350 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3354 { "Internal Mic", 0x1 },
3356 { "Docking-Station", 0x4 },
3362 * Dell Precision T3400
3364 static struct hda_input_mux ad1984_dell_desktop_capture_source = {
3367 { "Front Mic", 0x0 },
3374 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3375 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3376 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3377 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3378 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3379 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3380 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3381 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3382 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3383 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3384 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3385 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3386 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3387 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3388 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3389 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3390 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3391 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3393 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3394 /* The multiple "Capture Source" controls confuse alsamixer
3395 * So call somewhat different..
3397 /* .name = "Capture Source", */
3398 .name = "Input Source",
3400 .info = ad198x_mux_enum_info,
3401 .get = ad198x_mux_enum_get,
3402 .put = ad198x_mux_enum_put,
3404 /* SPDIF controls */
3405 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3407 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3408 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3409 /* identical with ad1983 */
3410 .info = ad1983_spdif_route_info,
3411 .get = ad1983_spdif_route_get,
3412 .put = ad1983_spdif_route_put,
3417 /* additional verbs */
3418 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3419 /* Port-E (docking station mic) pin */
3420 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3421 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3422 /* docking mic boost */
3423 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3424 /* Analog mixer - docking mic; mute as default */
3425 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3426 /* enable EAPD bit */
3427 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3432 * Dell Precision T3400
3434 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3435 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3436 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3437 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3438 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3439 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3440 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3441 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3442 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3443 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3444 HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3445 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3446 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3447 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3448 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3449 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3451 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3452 /* The multiple "Capture Source" controls confuse alsamixer
3453 * So call somewhat different..
3455 /* .name = "Capture Source", */
3456 .name = "Input Source",
3458 .info = ad198x_mux_enum_info,
3459 .get = ad198x_mux_enum_get,
3460 .put = ad198x_mux_enum_put,
3465 /* Digial MIC ADC NID 0x05 + 0x06 */
3466 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3467 struct hda_codec *codec,
3468 unsigned int stream_tag,
3469 unsigned int format,
3470 struct snd_pcm_substream *substream)
3472 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3473 stream_tag, 0, format);
3477 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3478 struct hda_codec *codec,
3479 struct snd_pcm_substream *substream)
3481 snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number);
3485 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3491 .prepare = ad1984_pcm_dmic_prepare,
3492 .cleanup = ad1984_pcm_dmic_cleanup
3496 static int ad1984_build_pcms(struct hda_codec *codec)
3498 struct ad198x_spec *spec = codec->spec;
3499 struct hda_pcm *info;
3502 err = ad198x_build_pcms(codec);
3506 info = spec->pcm_rec + codec->num_pcms;
3508 info->name = "AD1984 Digital Mic";
3509 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3517 AD1984_DELL_DESKTOP,
3521 static const char *ad1984_models[AD1984_MODELS] = {
3522 [AD1984_BASIC] = "basic",
3523 [AD1984_THINKPAD] = "thinkpad",
3524 [AD1984_DELL_DESKTOP] = "dell_desktop",
3527 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3528 /* Lenovo Thinkpad T61/X61 */
3529 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD),
3530 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3534 static int patch_ad1984(struct hda_codec *codec)
3536 struct ad198x_spec *spec;
3537 int board_config, err;
3539 err = patch_ad1884(codec);
3543 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3544 ad1984_models, ad1984_cfg_tbl);
3545 switch (board_config) {
3547 /* additional digital mics */
3548 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3549 codec->patch_ops.build_pcms = ad1984_build_pcms;
3551 case AD1984_THINKPAD:
3552 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3553 spec->input_mux = &ad1984_thinkpad_capture_source;
3554 spec->mixers[0] = ad1984_thinkpad_mixers;
3555 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3557 case AD1984_DELL_DESKTOP:
3558 spec->multiout.dig_out_nid = 0;
3559 spec->input_mux = &ad1984_dell_desktop_capture_source;
3560 spec->mixers[0] = ad1984_dell_desktop_mixers;
3568 * AD1883 / AD1884A / AD1984A / AD1984B
3570 * port-B (0x14) - front mic-in
3571 * port-E (0x1c) - rear mic-in
3572 * port-F (0x16) - CD / ext out
3573 * port-C (0x15) - rear line-in
3574 * port-D (0x12) - rear line-out
3575 * port-A (0x11) - front hp-out
3577 * AD1984A = AD1884A + digital-mic
3578 * AD1883 = equivalent with AD1984A
3579 * AD1984B = AD1984A + extra SPDIF-out
3582 * We share the single DAC for both HP and line-outs (see AD1884/1984).
3585 static hda_nid_t ad1884a_dac_nids[1] = {
3589 #define ad1884a_adc_nids ad1884_adc_nids
3590 #define ad1884a_capsrc_nids ad1884_capsrc_nids
3592 #define AD1884A_SPDIF_OUT 0x02
3594 static struct hda_input_mux ad1884a_capture_source = {
3597 { "Front Mic", 0x0 },
3605 static struct snd_kcontrol_new ad1884a_base_mixers[] = {
3606 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3607 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3608 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3609 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3610 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3611 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3612 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3613 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3614 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3615 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3616 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
3617 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
3618 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3619 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3620 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3621 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3622 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3623 HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
3624 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3625 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3626 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3627 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3628 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3630 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3631 /* The multiple "Capture Source" controls confuse alsamixer
3632 * So call somewhat different..
3634 /* .name = "Capture Source", */
3635 .name = "Input Source",
3637 .info = ad198x_mux_enum_info,
3638 .get = ad198x_mux_enum_get,
3639 .put = ad198x_mux_enum_put,
3641 /* SPDIF controls */
3642 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3644 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3645 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3646 /* identical with ad1983 */
3647 .info = ad1983_spdif_route_info,
3648 .get = ad1983_spdif_route_get,
3649 .put = ad1983_spdif_route_put,
3655 * initialization verbs
3657 static struct hda_verb ad1884a_init_verbs[] = {
3658 /* DACs; unmute as default */
3659 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3660 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3661 /* Port-A (HP) mixer - route only from analog mixer */
3662 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3663 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3665 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3666 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3667 /* Port-D (Line-out) mixer - route only from analog mixer */
3668 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3669 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3671 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3672 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3673 /* Mono-out mixer - route only from analog mixer */
3674 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3675 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3677 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3678 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3679 /* Port-B (front mic) pin */
3680 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3681 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3682 /* Port-C (rear line-in) pin */
3683 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3684 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3685 /* Port-E (rear mic) pin */
3686 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3687 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3688 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
3689 /* Port-F (CD) pin */
3690 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3691 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3692 /* Analog mixer; mute as default */
3693 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3694 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3695 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3696 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3697 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
3698 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3699 /* Analog Mix output amp */
3700 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3701 /* capture sources */
3702 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
3703 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3704 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3705 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3706 /* SPDIF output amp */
3707 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3711 #ifdef CONFIG_SND_HDA_POWER_SAVE
3712 static struct hda_amp_list ad1884a_loopbacks[] = {
3713 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3714 { 0x20, HDA_INPUT, 1 }, /* Mic */
3715 { 0x20, HDA_INPUT, 2 }, /* CD */
3716 { 0x20, HDA_INPUT, 4 }, /* Docking */
3724 * Port A: Headphone jack
3726 * Port C: Internal MIC
3727 * Port D: Dock Line Out (if enabled)
3728 * Port E: Dock Line In (if enabled)
3729 * Port F: Internal speakers
3732 static int ad1884a_mobile_master_sw_put(struct snd_kcontrol *kcontrol,
3733 struct snd_ctl_elem_value *ucontrol)
3735 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3736 int ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3737 int mute = (!ucontrol->value.integer.value[0] &&
3738 !ucontrol->value.integer.value[1]);
3739 /* toggle GPIO1 according to the mute state */
3740 snd_hda_codec_write_cache(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3745 static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
3746 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3748 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3749 .name = "Master Playback Switch",
3750 .info = snd_hda_mixer_amp_switch_info,
3751 .get = snd_hda_mixer_amp_switch_get,
3752 .put = ad1884a_mobile_master_sw_put,
3753 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
3755 HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3756 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3757 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3758 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3759 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3760 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3761 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3762 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3763 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3764 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3765 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3766 HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3767 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3768 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3772 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
3773 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3774 /*HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
3776 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3777 .name = "Master Playback Switch",
3778 .info = snd_hda_mixer_amp_switch_info,
3779 .get = snd_hda_mixer_amp_switch_get,
3780 .put = ad1884a_mobile_master_sw_put,
3781 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
3783 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3784 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3785 HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
3786 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
3787 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3788 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3792 /* mute internal speaker if HP is plugged */
3793 static void ad1884a_hp_automute(struct hda_codec *codec)
3795 unsigned int present;
3797 present = snd_hda_jack_detect(codec, 0x11);
3798 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3799 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3800 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3801 present ? 0x00 : 0x02);
3804 /* switch to external mic if plugged */
3805 static void ad1884a_hp_automic(struct hda_codec *codec)
3807 unsigned int present;
3809 present = snd_hda_jack_detect(codec, 0x14);
3810 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
3814 #define AD1884A_HP_EVENT 0x37
3815 #define AD1884A_MIC_EVENT 0x36
3817 /* unsolicited event for HP jack sensing */
3818 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
3820 switch (res >> 26) {
3821 case AD1884A_HP_EVENT:
3822 ad1884a_hp_automute(codec);
3824 case AD1884A_MIC_EVENT:
3825 ad1884a_hp_automic(codec);
3830 /* initialize jack-sensing, too */
3831 static int ad1884a_hp_init(struct hda_codec *codec)
3834 ad1884a_hp_automute(codec);
3835 ad1884a_hp_automic(codec);
3839 /* mute internal speaker if HP or docking HP is plugged */
3840 static void ad1884a_laptop_automute(struct hda_codec *codec)
3842 unsigned int present;
3844 present = snd_hda_jack_detect(codec, 0x11);
3846 present = snd_hda_jack_detect(codec, 0x12);
3847 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3848 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3849 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3850 present ? 0x00 : 0x02);
3853 /* switch to external mic if plugged */
3854 static void ad1884a_laptop_automic(struct hda_codec *codec)
3858 if (snd_hda_jack_detect(codec, 0x14))
3860 else if (snd_hda_jack_detect(codec, 0x1c))
3864 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, idx);
3867 /* unsolicited event for HP jack sensing */
3868 static void ad1884a_laptop_unsol_event(struct hda_codec *codec,
3871 switch (res >> 26) {
3872 case AD1884A_HP_EVENT:
3873 ad1884a_laptop_automute(codec);
3875 case AD1884A_MIC_EVENT:
3876 ad1884a_laptop_automic(codec);
3881 /* initialize jack-sensing, too */
3882 static int ad1884a_laptop_init(struct hda_codec *codec)
3885 ad1884a_laptop_automute(codec);
3886 ad1884a_laptop_automic(codec);
3890 /* additional verbs for laptop model */
3891 static struct hda_verb ad1884a_laptop_verbs[] = {
3892 /* Port-A (HP) pin - always unmuted */
3893 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3894 /* Port-F (int speaker) mixer - route only from analog mixer */
3895 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3896 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3897 /* Port-F (int speaker) pin */
3898 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3899 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3900 /* required for compaq 6530s/6531s speaker output */
3901 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3902 /* Port-C pin - internal mic-in */
3903 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3904 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3905 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3906 /* Port-D (docking line-out) pin - default unmuted */
3907 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3909 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3910 /* unsolicited event for pin-sense */
3911 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3912 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3913 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
3914 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
3915 /* allow to touch GPIO1 (for mute control) */
3916 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
3917 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
3918 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
3922 static struct hda_verb ad1884a_mobile_verbs[] = {
3923 /* DACs; unmute as default */
3924 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3925 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3926 /* Port-A (HP) mixer - route only from analog mixer */
3927 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3928 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3930 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3931 /* Port-A (HP) pin - always unmuted */
3932 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3933 /* Port-B (mic jack) pin */
3934 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3935 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3936 /* Port-C (int mic) pin */
3937 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3938 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3939 /* Port-F (int speaker) mixer - route only from analog mixer */
3940 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3941 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3943 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3944 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3945 /* Analog mixer; mute as default */
3946 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3947 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3948 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3949 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3950 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3951 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3952 /* Analog Mix output amp */
3953 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3954 /* capture sources */
3955 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
3956 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3957 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3958 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3959 /* unsolicited event for pin-sense */
3960 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3961 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
3962 /* allow to touch GPIO1 (for mute control) */
3963 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
3964 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
3965 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
3974 * 0x17 - built-in mic
3977 static struct hda_verb ad1984a_thinkpad_verbs[] = {
3979 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3981 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3983 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3984 /* unsolicited event for pin-sense */
3985 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3986 /* internal mic - dmic */
3987 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3988 /* set magic COEFs for dmic */
3989 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
3990 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
3994 static struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
3995 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3996 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3997 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3998 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3999 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4000 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4001 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
4002 HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
4003 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4004 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4006 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4007 .name = "Capture Source",
4008 .info = ad198x_mux_enum_info,
4009 .get = ad198x_mux_enum_get,
4010 .put = ad198x_mux_enum_put,
4015 static struct hda_input_mux ad1984a_thinkpad_capture_source = {
4019 { "Internal Mic", 0x5 },
4024 /* mute internal speaker if HP is plugged */
4025 static void ad1984a_thinkpad_automute(struct hda_codec *codec)
4027 unsigned int present;
4029 present = snd_hda_jack_detect(codec, 0x11);
4030 snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
4031 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4034 /* unsolicited event for HP jack sensing */
4035 static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec,
4038 if ((res >> 26) != AD1884A_HP_EVENT)
4040 ad1984a_thinkpad_automute(codec);
4043 /* initialize jack-sensing, too */
4044 static int ad1984a_thinkpad_init(struct hda_codec *codec)
4047 ad1984a_thinkpad_automute(codec);
4053 * port-A (0x11) - front hp-out
4054 * port-B (0x14) - unused
4055 * port-C (0x15) - unused
4056 * port-D (0x12) - rear line out
4057 * port-E (0x1c) - front mic-in
4058 * port-F (0x16) - Internal speakers
4059 * digital-mic (0x17) - Internal mic
4062 static struct hda_verb ad1984a_touchsmart_verbs[] = {
4063 /* DACs; unmute as default */
4064 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4065 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4066 /* Port-A (HP) mixer - route only from analog mixer */
4067 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4068 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4070 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4071 /* Port-A (HP) pin - always unmuted */
4072 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4073 /* Port-E (int speaker) mixer - route only from analog mixer */
4074 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, 0x03},
4076 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4077 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4078 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4079 /* Port-F (int speaker) mixer - route only from analog mixer */
4080 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4081 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4083 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4084 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4085 /* Analog mixer; mute as default */
4086 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4087 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4088 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4089 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4090 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4091 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4092 /* Analog Mix output amp */
4093 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4094 /* capture sources */
4095 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4096 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4097 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4098 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4099 /* unsolicited event for pin-sense */
4100 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4101 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4102 /* allow to touch GPIO1 (for mute control) */
4103 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4104 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4105 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4106 /* internal mic - dmic */
4107 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4108 /* set magic COEFs for dmic */
4109 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4110 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4114 static struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = {
4115 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4116 /* HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
4118 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4119 .name = "Master Playback Switch",
4120 .info = snd_hda_mixer_amp_switch_info,
4121 .get = snd_hda_mixer_amp_switch_get,
4122 .put = ad1884a_mobile_master_sw_put,
4123 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4125 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4126 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4127 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4128 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4129 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
4130 HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
4134 /* switch to external mic if plugged */
4135 static void ad1984a_touchsmart_automic(struct hda_codec *codec)
4137 if (snd_hda_jack_detect(codec, 0x1c))
4138 snd_hda_codec_write(codec, 0x0c, 0,
4139 AC_VERB_SET_CONNECT_SEL, 0x4);
4141 snd_hda_codec_write(codec, 0x0c, 0,
4142 AC_VERB_SET_CONNECT_SEL, 0x5);
4146 /* unsolicited event for HP jack sensing */
4147 static void ad1984a_touchsmart_unsol_event(struct hda_codec *codec,
4150 switch (res >> 26) {
4151 case AD1884A_HP_EVENT:
4152 ad1884a_hp_automute(codec);
4154 case AD1884A_MIC_EVENT:
4155 ad1984a_touchsmart_automic(codec);
4160 /* initialize jack-sensing, too */
4161 static int ad1984a_touchsmart_init(struct hda_codec *codec)
4164 ad1884a_hp_automute(codec);
4165 ad1984a_touchsmart_automic(codec);
4182 static const char *ad1884a_models[AD1884A_MODELS] = {
4183 [AD1884A_DESKTOP] = "desktop",
4184 [AD1884A_LAPTOP] = "laptop",
4185 [AD1884A_MOBILE] = "mobile",
4186 [AD1884A_THINKPAD] = "thinkpad",
4187 [AD1984A_TOUCHSMART] = "touchsmart",
4190 static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
4191 SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
4192 SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
4193 SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
4194 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE),
4195 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30d0, "HP laptop", AD1884A_LAPTOP),
4196 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP),
4197 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP),
4198 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x7010, "HP laptop", AD1884A_MOBILE),
4199 SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
4200 SND_PCI_QUIRK(0x103c, 0x2a82, "Touchsmart", AD1984A_TOUCHSMART),
4204 static int patch_ad1884a(struct hda_codec *codec)
4206 struct ad198x_spec *spec;
4207 int err, board_config;
4209 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4215 err = snd_hda_attach_beep_device(codec, 0x10);
4220 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4222 spec->multiout.max_channels = 2;
4223 spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
4224 spec->multiout.dac_nids = ad1884a_dac_nids;
4225 spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
4226 spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
4227 spec->adc_nids = ad1884a_adc_nids;
4228 spec->capsrc_nids = ad1884a_capsrc_nids;
4229 spec->input_mux = &ad1884a_capture_source;
4230 spec->num_mixers = 1;
4231 spec->mixers[0] = ad1884a_base_mixers;
4232 spec->num_init_verbs = 1;
4233 spec->init_verbs[0] = ad1884a_init_verbs;
4234 spec->spdif_route = 0;
4235 #ifdef CONFIG_SND_HDA_POWER_SAVE
4236 spec->loopback.amplist = ad1884a_loopbacks;
4238 codec->patch_ops = ad198x_patch_ops;
4240 /* override some parameters */
4241 board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
4244 switch (board_config) {
4245 case AD1884A_LAPTOP:
4246 spec->mixers[0] = ad1884a_laptop_mixers;
4247 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
4248 spec->multiout.dig_out_nid = 0;
4249 codec->patch_ops.unsol_event = ad1884a_laptop_unsol_event;
4250 codec->patch_ops.init = ad1884a_laptop_init;
4251 /* set the upper-limit for mixer amp to 0dB for avoiding the
4252 * possible damage by overloading
4254 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4255 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4256 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4257 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4258 (1 << AC_AMPCAP_MUTE_SHIFT));
4260 case AD1884A_MOBILE:
4261 spec->mixers[0] = ad1884a_mobile_mixers;
4262 spec->init_verbs[0] = ad1884a_mobile_verbs;
4263 spec->multiout.dig_out_nid = 0;
4264 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
4265 codec->patch_ops.init = ad1884a_hp_init;
4266 /* set the upper-limit for mixer amp to 0dB for avoiding the
4267 * possible damage by overloading
4269 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4270 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4271 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4272 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4273 (1 << AC_AMPCAP_MUTE_SHIFT));
4275 case AD1884A_THINKPAD:
4276 spec->mixers[0] = ad1984a_thinkpad_mixers;
4277 spec->init_verbs[spec->num_init_verbs++] =
4278 ad1984a_thinkpad_verbs;
4279 spec->multiout.dig_out_nid = 0;
4280 spec->input_mux = &ad1984a_thinkpad_capture_source;
4281 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
4282 codec->patch_ops.init = ad1984a_thinkpad_init;
4284 case AD1984A_TOUCHSMART:
4285 spec->mixers[0] = ad1984a_touchsmart_mixers;
4286 spec->init_verbs[0] = ad1984a_touchsmart_verbs;
4287 spec->multiout.dig_out_nid = 0;
4288 codec->patch_ops.unsol_event = ad1984a_touchsmart_unsol_event;
4289 codec->patch_ops.init = ad1984a_touchsmart_init;
4290 /* set the upper-limit for mixer amp to 0dB for avoiding the
4291 * possible damage by overloading
4293 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4294 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4295 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4296 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4297 (1 << AC_AMPCAP_MUTE_SHIFT));
4301 codec->no_trigger_sense = 1;
4310 * port-A - front hp-out
4311 * port-B - front mic-in
4312 * port-C - rear line-in, shared surr-out (3stack)
4313 * port-D - rear line-out
4314 * port-E - rear mic-in, shared clfe-out (3stack)
4315 * port-F - rear surr-out (6stack)
4316 * port-G - rear clfe-out (6stack)
4319 static hda_nid_t ad1882_dac_nids[3] = {
4323 static hda_nid_t ad1882_adc_nids[2] = {
4327 static hda_nid_t ad1882_capsrc_nids[2] = {
4331 #define AD1882_SPDIF_OUT 0x02
4333 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
4334 static struct hda_input_mux ad1882_capture_source = {
4337 { "Front Mic", 0x1 },
4345 /* list: 0x11, 0x39, 0x3a, 0x3c, 0x18, 0x1f, 0x12, 0x20 */
4346 static struct hda_input_mux ad1882a_capture_source = {
4349 { "Front Mic", 0x1 },
4352 { "Digital Mic", 0x06 },
4357 static struct snd_kcontrol_new ad1882_base_mixers[] = {
4358 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
4359 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
4360 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
4361 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
4362 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
4363 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4364 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
4365 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
4367 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
4368 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
4369 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
4370 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4371 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4372 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
4373 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
4375 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4376 /* The multiple "Capture Source" controls confuse alsamixer
4377 * So call somewhat different..
4379 /* .name = "Capture Source", */
4380 .name = "Input Source",
4382 .info = ad198x_mux_enum_info,
4383 .get = ad198x_mux_enum_get,
4384 .put = ad198x_mux_enum_put,
4386 /* SPDIF controls */
4387 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
4389 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4390 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4391 /* identical with ad1983 */
4392 .info = ad1983_spdif_route_info,
4393 .get = ad1983_spdif_route_get,
4394 .put = ad1983_spdif_route_put,
4399 static struct snd_kcontrol_new ad1882_loopback_mixers[] = {
4400 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4401 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4402 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4403 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4404 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
4405 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
4406 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4407 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4411 static struct snd_kcontrol_new ad1882a_loopback_mixers[] = {
4412 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4413 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4414 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4415 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4416 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
4417 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4418 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4419 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4420 HDA_CODEC_VOLUME("Digital Mic Boost", 0x1f, 0x0, HDA_INPUT),
4424 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
4425 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4426 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
4427 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
4429 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4430 .name = "Channel Mode",
4431 .info = ad198x_ch_mode_info,
4432 .get = ad198x_ch_mode_get,
4433 .put = ad198x_ch_mode_put,
4438 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
4439 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
4440 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
4441 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
4445 static struct hda_verb ad1882_ch2_init[] = {
4446 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4447 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4448 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4449 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4450 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4451 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4455 static struct hda_verb ad1882_ch4_init[] = {
4456 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4457 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4458 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4459 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4460 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4461 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4465 static struct hda_verb ad1882_ch6_init[] = {
4466 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4467 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4468 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4469 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4470 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4471 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4475 static struct hda_channel_mode ad1882_modes[3] = {
4476 { 2, ad1882_ch2_init },
4477 { 4, ad1882_ch4_init },
4478 { 6, ad1882_ch6_init },
4482 * initialization verbs
4484 static struct hda_verb ad1882_init_verbs[] = {
4485 /* DACs; mute as default */
4486 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4487 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4488 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4489 /* Port-A (HP) mixer */
4490 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4491 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4493 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4494 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4495 /* HP selector - select DAC2 */
4496 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
4497 /* Port-D (Line-out) mixer */
4498 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4499 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4501 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4502 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4503 /* Mono-out mixer */
4504 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4505 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4507 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4508 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4509 /* Port-B (front mic) pin */
4510 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4511 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4512 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4513 /* Port-C (line-in) pin */
4514 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4515 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4516 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4517 /* Port-C mixer - mute as input */
4518 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4519 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4520 /* Port-E (mic-in) pin */
4521 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4522 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4523 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4524 /* Port-E mixer - mute as input */
4525 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4526 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4527 /* Port-F (surround) */
4528 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4529 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4531 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4532 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4533 /* Analog mixer; mute as default */
4534 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
4535 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4536 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4537 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4538 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4539 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4540 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4541 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
4542 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4543 /* Analog Mix output amp */
4544 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
4545 /* SPDIF output selector */
4546 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4547 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
4548 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4552 #ifdef CONFIG_SND_HDA_POWER_SAVE
4553 static struct hda_amp_list ad1882_loopbacks[] = {
4554 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4555 { 0x20, HDA_INPUT, 1 }, /* Mic */
4556 { 0x20, HDA_INPUT, 4 }, /* Line */
4557 { 0x20, HDA_INPUT, 6 }, /* CD */
4569 static const char *ad1882_models[AD1986A_MODELS] = {
4570 [AD1882_3STACK] = "3stack",
4571 [AD1882_6STACK] = "6stack",
4575 static int patch_ad1882(struct hda_codec *codec)
4577 struct ad198x_spec *spec;
4578 int err, board_config;
4580 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4586 err = snd_hda_attach_beep_device(codec, 0x10);
4591 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4593 spec->multiout.max_channels = 6;
4594 spec->multiout.num_dacs = 3;
4595 spec->multiout.dac_nids = ad1882_dac_nids;
4596 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
4597 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
4598 spec->adc_nids = ad1882_adc_nids;
4599 spec->capsrc_nids = ad1882_capsrc_nids;
4600 if (codec->vendor_id == 0x11d41882)
4601 spec->input_mux = &ad1882_capture_source;
4603 spec->input_mux = &ad1882a_capture_source;
4604 spec->num_mixers = 2;
4605 spec->mixers[0] = ad1882_base_mixers;
4606 if (codec->vendor_id == 0x11d41882)
4607 spec->mixers[1] = ad1882_loopback_mixers;
4609 spec->mixers[1] = ad1882a_loopback_mixers;
4610 spec->num_init_verbs = 1;
4611 spec->init_verbs[0] = ad1882_init_verbs;
4612 spec->spdif_route = 0;
4613 #ifdef CONFIG_SND_HDA_POWER_SAVE
4614 spec->loopback.amplist = ad1882_loopbacks;
4616 spec->vmaster_nid = 0x04;
4618 codec->patch_ops = ad198x_patch_ops;
4620 /* override some parameters */
4621 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
4622 ad1882_models, NULL);
4623 switch (board_config) {
4626 spec->num_mixers = 3;
4627 spec->mixers[2] = ad1882_3stack_mixers;
4628 spec->channel_mode = ad1882_modes;
4629 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
4630 spec->need_dac_fix = 1;
4631 spec->multiout.max_channels = 2;
4632 spec->multiout.num_dacs = 1;
4635 spec->num_mixers = 3;
4636 spec->mixers[2] = ad1882_6stack_mixers;
4640 codec->no_trigger_sense = 1;
4649 static struct hda_codec_preset snd_hda_preset_analog[] = {
4650 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
4651 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
4652 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
4653 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
4654 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
4655 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
4656 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
4657 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
4658 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
4659 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
4660 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
4661 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
4662 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 },
4663 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },
4664 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },
4668 MODULE_ALIAS("snd-hda-codec-id:11d4*");
4670 MODULE_LICENSE("GPL");
4671 MODULE_DESCRIPTION("Analog Devices HD-audio codec");
4673 static struct hda_codec_preset_list analog_list = {
4674 .preset = snd_hda_preset_analog,
4675 .owner = THIS_MODULE,
4678 static int __init patch_analog_init(void)
4680 return snd_hda_add_codec_preset(&analog_list);
4683 static void __exit patch_analog_exit(void)
4685 snd_hda_delete_codec_preset(&analog_list);
4688 module_init(patch_analog_init)
4689 module_exit(patch_analog_exit)