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"
30 #include "hda_patch.h"
33 struct snd_kcontrol_new *mixers[5];
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 unsigned int num_kctl_alloc, num_kctl_used;
71 struct snd_kcontrol_new *kctl_alloc;
72 struct hda_input_mux private_imux;
73 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
75 unsigned int jack_present :1;
77 #ifdef CONFIG_SND_HDA_POWER_SAVE
78 struct hda_loopback_check loopback;
80 /* for virtual master */
81 hda_nid_t vmaster_nid;
82 const char **slave_vols;
83 const char **slave_sws;
87 * input MUX handling (common part)
89 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
91 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
92 struct ad198x_spec *spec = codec->spec;
94 return snd_hda_input_mux_info(spec->input_mux, uinfo);
97 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
99 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
100 struct ad198x_spec *spec = codec->spec;
101 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
103 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
107 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
109 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
110 struct ad198x_spec *spec = codec->spec;
111 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
113 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
114 spec->capsrc_nids[adc_idx],
115 &spec->cur_mux[adc_idx]);
119 * initialization (common callbacks)
121 static int ad198x_init(struct hda_codec *codec)
123 struct ad198x_spec *spec = codec->spec;
126 for (i = 0; i < spec->num_init_verbs; i++)
127 snd_hda_sequence_write(codec, spec->init_verbs[i]);
131 static const char *ad_slave_vols[] = {
132 "Front Playback Volume",
133 "Surround Playback Volume",
134 "Center Playback Volume",
135 "LFE Playback Volume",
136 "Side Playback Volume",
137 "Headphone Playback Volume",
138 "Mono Playback Volume",
139 "Speaker Playback Volume",
140 "IEC958 Playback Volume",
144 static const char *ad_slave_sws[] = {
145 "Front Playback Switch",
146 "Surround Playback Switch",
147 "Center Playback Switch",
148 "LFE Playback Switch",
149 "Side Playback Switch",
150 "Headphone Playback Switch",
151 "Mono Playback Switch",
152 "Speaker Playback Switch",
153 "IEC958 Playback Switch",
157 static int ad198x_build_controls(struct hda_codec *codec)
159 struct ad198x_spec *spec = codec->spec;
163 for (i = 0; i < spec->num_mixers; i++) {
164 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
168 if (spec->multiout.dig_out_nid) {
169 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
172 err = snd_hda_create_spdif_share_sw(codec,
176 spec->multiout.share_spdif = 1;
178 if (spec->dig_in_nid) {
179 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
184 /* if we have no master control, let's create it */
185 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
186 unsigned int vmaster_tlv[4];
187 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
188 HDA_OUTPUT, vmaster_tlv);
189 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
192 spec->slave_vols : ad_slave_vols));
196 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
197 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
200 spec->slave_sws : ad_slave_sws));
208 #ifdef CONFIG_SND_HDA_POWER_SAVE
209 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
211 struct ad198x_spec *spec = codec->spec;
212 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
217 * Analog playback callbacks
219 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
220 struct hda_codec *codec,
221 struct snd_pcm_substream *substream)
223 struct ad198x_spec *spec = codec->spec;
224 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
228 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
229 struct hda_codec *codec,
230 unsigned int stream_tag,
232 struct snd_pcm_substream *substream)
234 struct ad198x_spec *spec = codec->spec;
235 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
239 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
240 struct hda_codec *codec,
241 struct snd_pcm_substream *substream)
243 struct ad198x_spec *spec = codec->spec;
244 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
250 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
251 struct hda_codec *codec,
252 struct snd_pcm_substream *substream)
254 struct ad198x_spec *spec = codec->spec;
255 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
258 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
259 struct hda_codec *codec,
260 struct snd_pcm_substream *substream)
262 struct ad198x_spec *spec = codec->spec;
263 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
266 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
267 struct hda_codec *codec,
268 unsigned int stream_tag,
270 struct snd_pcm_substream *substream)
272 struct ad198x_spec *spec = codec->spec;
273 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
280 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
281 struct hda_codec *codec,
282 unsigned int stream_tag,
284 struct snd_pcm_substream *substream)
286 struct ad198x_spec *spec = codec->spec;
287 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
288 stream_tag, 0, format);
292 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
293 struct hda_codec *codec,
294 struct snd_pcm_substream *substream)
296 struct ad198x_spec *spec = codec->spec;
297 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
304 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
307 .channels_max = 6, /* changed later */
308 .nid = 0, /* fill later */
310 .open = ad198x_playback_pcm_open,
311 .prepare = ad198x_playback_pcm_prepare,
312 .cleanup = ad198x_playback_pcm_cleanup
316 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
320 .nid = 0, /* fill later */
322 .prepare = ad198x_capture_pcm_prepare,
323 .cleanup = ad198x_capture_pcm_cleanup
327 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
331 .nid = 0, /* fill later */
333 .open = ad198x_dig_playback_pcm_open,
334 .close = ad198x_dig_playback_pcm_close,
335 .prepare = ad198x_dig_playback_pcm_prepare
339 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
343 /* NID is set in alc_build_pcms */
346 static int ad198x_build_pcms(struct hda_codec *codec)
348 struct ad198x_spec *spec = codec->spec;
349 struct hda_pcm *info = spec->pcm_rec;
352 codec->pcm_info = info;
354 info->name = "AD198x Analog";
355 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
356 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
357 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
358 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
359 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
360 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
362 if (spec->multiout.dig_out_nid) {
365 info->name = "AD198x Digital";
366 info->pcm_type = HDA_PCM_TYPE_SPDIF;
367 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
368 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
369 if (spec->dig_in_nid) {
370 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
371 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
378 static void ad198x_free(struct hda_codec *codec)
380 struct ad198x_spec *spec = codec->spec;
383 if (spec->kctl_alloc) {
384 for (i = 0; i < spec->num_kctl_used; i++)
385 kfree(spec->kctl_alloc[i].name);
386 kfree(spec->kctl_alloc);
391 static struct hda_codec_ops ad198x_patch_ops = {
392 .build_controls = ad198x_build_controls,
393 .build_pcms = ad198x_build_pcms,
396 #ifdef CONFIG_SND_HDA_POWER_SAVE
397 .check_power_status = ad198x_check_power_status,
404 * the private value = nid | (invert << 8)
406 #define ad198x_eapd_info snd_ctl_boolean_mono_info
408 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
409 struct snd_ctl_elem_value *ucontrol)
411 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
412 struct ad198x_spec *spec = codec->spec;
413 int invert = (kcontrol->private_value >> 8) & 1;
415 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
417 ucontrol->value.integer.value[0] = spec->cur_eapd;
421 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
422 struct snd_ctl_elem_value *ucontrol)
424 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
425 struct ad198x_spec *spec = codec->spec;
426 int invert = (kcontrol->private_value >> 8) & 1;
427 hda_nid_t nid = kcontrol->private_value & 0xff;
429 eapd = !!ucontrol->value.integer.value[0];
432 if (eapd == spec->cur_eapd)
434 spec->cur_eapd = eapd;
435 snd_hda_codec_write_cache(codec, nid,
436 0, AC_VERB_SET_EAPD_BTLENABLE,
441 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
442 struct snd_ctl_elem_info *uinfo);
443 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
444 struct snd_ctl_elem_value *ucontrol);
445 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
446 struct snd_ctl_elem_value *ucontrol);
453 #define AD1986A_SPDIF_OUT 0x02
454 #define AD1986A_FRONT_DAC 0x03
455 #define AD1986A_SURR_DAC 0x04
456 #define AD1986A_CLFE_DAC 0x05
457 #define AD1986A_ADC 0x06
459 static hda_nid_t ad1986a_dac_nids[3] = {
460 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
462 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
463 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
465 static struct hda_input_mux ad1986a_capture_source = {
479 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
480 .ops = &snd_hda_bind_vol,
482 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
483 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
484 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
489 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
490 .ops = &snd_hda_bind_sw,
492 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
493 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
494 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
502 static struct snd_kcontrol_new ad1986a_mixers[] = {
504 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
506 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
507 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
508 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
509 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
510 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
511 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
512 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
513 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
514 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
515 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
516 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
517 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
518 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
519 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
520 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
521 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
522 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
523 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
524 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
525 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
526 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
527 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
528 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
529 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
530 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
531 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
532 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
534 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
535 .name = "Capture Source",
536 .info = ad198x_mux_enum_info,
537 .get = ad198x_mux_enum_get,
538 .put = ad198x_mux_enum_put,
540 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
544 /* additional mixers for 3stack mode */
545 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
547 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
548 .name = "Channel Mode",
549 .info = ad198x_ch_mode_info,
550 .get = ad198x_ch_mode_get,
551 .put = ad198x_ch_mode_put,
556 /* laptop model - 2ch only */
557 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
559 /* master controls both pins 0x1a and 0x1b */
560 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
561 .ops = &snd_hda_bind_vol,
563 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
564 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
569 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
570 .ops = &snd_hda_bind_sw,
572 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
573 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
578 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
579 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
580 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
581 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
582 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
583 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
584 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
585 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
586 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
587 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
588 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
589 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
590 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
591 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
592 /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
593 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
594 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
595 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
596 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
597 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
599 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
600 .name = "Capture Source",
601 .info = ad198x_mux_enum_info,
602 .get = ad198x_mux_enum_get,
603 .put = ad198x_mux_enum_put,
608 /* laptop-eapd model - 2ch only */
610 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
614 { "Internal Mic", 0x4 },
619 static struct hda_input_mux ad1986a_automic_capture_source = {
627 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
628 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
629 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
630 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
631 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
632 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
633 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
634 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
635 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
636 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
638 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
639 .name = "Capture Source",
640 .info = ad198x_mux_enum_info,
641 .get = ad198x_mux_enum_get,
642 .put = ad198x_mux_enum_put,
645 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
646 .name = "External Amplifier",
647 .info = ad198x_eapd_info,
648 .get = ad198x_eapd_get,
649 .put = ad198x_eapd_put,
650 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
655 /* re-connect the mic boost input according to the jack sensing */
656 static void ad1986a_automic(struct hda_codec *codec)
658 unsigned int present;
659 present = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_PIN_SENSE, 0);
660 /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
661 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
662 (present & AC_PINSENSE_PRESENCE) ? 0 : 2);
665 #define AD1986A_MIC_EVENT 0x36
667 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
670 if ((res >> 26) != AD1986A_MIC_EVENT)
672 ad1986a_automic(codec);
675 static int ad1986a_automic_init(struct hda_codec *codec)
678 ad1986a_automic(codec);
682 /* laptop-automute - 2ch only */
684 static void ad1986a_update_hp(struct hda_codec *codec)
686 struct ad198x_spec *spec = codec->spec;
689 if (spec->jack_present)
690 mute = HDA_AMP_MUTE; /* mute internal speaker */
692 /* unmute internal speaker if necessary */
693 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
694 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
698 static void ad1986a_hp_automute(struct hda_codec *codec)
700 struct ad198x_spec *spec = codec->spec;
701 unsigned int present;
703 present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
704 /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
705 spec->jack_present = !(present & 0x80000000);
706 ad1986a_update_hp(codec);
709 #define AD1986A_HP_EVENT 0x37
711 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
713 if ((res >> 26) != AD1986A_HP_EVENT)
715 ad1986a_hp_automute(codec);
718 static int ad1986a_hp_init(struct hda_codec *codec)
721 ad1986a_hp_automute(codec);
725 /* bind hp and internal speaker mute (with plug check) */
726 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
727 struct snd_ctl_elem_value *ucontrol)
729 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
730 long *valp = ucontrol->value.integer.value;
733 change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
735 valp[0] ? 0 : HDA_AMP_MUTE);
736 change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
738 valp[1] ? 0 : HDA_AMP_MUTE);
740 ad1986a_update_hp(codec);
744 static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
745 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
747 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
748 .name = "Master Playback Switch",
749 .info = snd_hda_mixer_amp_switch_info,
750 .get = snd_hda_mixer_amp_switch_get,
751 .put = ad1986a_hp_master_sw_put,
752 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
754 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
755 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
756 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
757 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
758 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
759 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
760 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
761 HDA_CODEC_VOLUME("Beep Playback Volume", 0x18, 0x0, HDA_OUTPUT),
762 HDA_CODEC_MUTE("Beep Playback Switch", 0x18, 0x0, HDA_OUTPUT),
763 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
764 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
766 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
767 .name = "Capture Source",
768 .info = ad198x_mux_enum_info,
769 .get = ad198x_mux_enum_get,
770 .put = ad198x_mux_enum_put,
773 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
774 .name = "External Amplifier",
775 .info = ad198x_eapd_info,
776 .get = ad198x_eapd_get,
777 .put = ad198x_eapd_put,
778 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
784 * initialization verbs
786 static struct hda_verb ad1986a_init_verbs[] = {
787 /* Front, Surround, CLFE DAC; mute as default */
788 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
789 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
790 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
792 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
793 /* HP, Line-Out, Surround, CLFE selectors */
794 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
795 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
796 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
797 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
799 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
800 /* Mic selector: Mic 1/2 pin */
801 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
802 /* Line-in selector: Line-in */
803 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
805 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
806 /* Record selector: mic */
807 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
808 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
809 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
810 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
811 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
812 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
813 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
815 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
816 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
817 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
818 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
819 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
820 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
821 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
823 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
824 /* Front, Surround, CLFE Pins */
825 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
826 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
827 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
829 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
831 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
832 /* Line, Aux, CD, Beep-In Pin */
833 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
834 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
835 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
836 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
837 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
841 static struct hda_verb ad1986a_ch2_init[] = {
842 /* Surround out -> Line In */
843 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
844 /* Line-in selectors */
845 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
847 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
848 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
849 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
853 static struct hda_verb ad1986a_ch4_init[] = {
854 /* Surround out -> Surround */
855 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
856 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
858 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
859 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
863 static struct hda_verb ad1986a_ch6_init[] = {
864 /* Surround out -> Surround out */
865 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
866 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
868 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
869 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
873 static struct hda_channel_mode ad1986a_modes[3] = {
874 { 2, ad1986a_ch2_init },
875 { 4, ad1986a_ch4_init },
876 { 6, ad1986a_ch6_init },
879 /* eapd initialization */
880 static struct hda_verb ad1986a_eapd_init_verbs[] = {
881 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
885 static struct hda_verb ad1986a_automic_verbs[] = {
886 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
887 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
888 /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
889 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
890 {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
894 /* Ultra initialization */
895 static struct hda_verb ad1986a_ultra_init[] = {
896 /* eapd initialization */
897 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
899 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
900 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
901 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
905 /* pin sensing on HP jack */
906 static struct hda_verb ad1986a_hp_init_verbs[] = {
907 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
918 AD1986A_LAPTOP_AUTOMUTE,
923 static const char *ad1986a_models[AD1986A_MODELS] = {
924 [AD1986A_6STACK] = "6stack",
925 [AD1986A_3STACK] = "3stack",
926 [AD1986A_LAPTOP] = "laptop",
927 [AD1986A_LAPTOP_EAPD] = "laptop-eapd",
928 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
929 [AD1986A_ULTRA] = "ultra",
932 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
933 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
934 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
935 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
936 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
937 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
938 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
939 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
940 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
941 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
942 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
943 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
944 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
945 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
946 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
947 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
948 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
949 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
950 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
951 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
952 SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_LAPTOP_EAPD),
953 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_LAPTOP_EAPD),
954 SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_LAPTOP_EAPD),
955 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
956 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
957 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
958 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
959 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
960 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
964 #ifdef CONFIG_SND_HDA_POWER_SAVE
965 static struct hda_amp_list ad1986a_loopbacks[] = {
966 { 0x13, HDA_OUTPUT, 0 }, /* Mic */
967 { 0x14, HDA_OUTPUT, 0 }, /* Phone */
968 { 0x15, HDA_OUTPUT, 0 }, /* CD */
969 { 0x16, HDA_OUTPUT, 0 }, /* Aux */
970 { 0x17, HDA_OUTPUT, 0 }, /* Line */
975 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
977 unsigned int conf = snd_hda_codec_read(codec, nid, 0,
978 AC_VERB_GET_CONFIG_DEFAULT, 0);
979 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
982 static int patch_ad1986a(struct hda_codec *codec)
984 struct ad198x_spec *spec;
987 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
993 spec->multiout.max_channels = 6;
994 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
995 spec->multiout.dac_nids = ad1986a_dac_nids;
996 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
997 spec->num_adc_nids = 1;
998 spec->adc_nids = ad1986a_adc_nids;
999 spec->capsrc_nids = ad1986a_capsrc_nids;
1000 spec->input_mux = &ad1986a_capture_source;
1001 spec->num_mixers = 1;
1002 spec->mixers[0] = ad1986a_mixers;
1003 spec->num_init_verbs = 1;
1004 spec->init_verbs[0] = ad1986a_init_verbs;
1005 #ifdef CONFIG_SND_HDA_POWER_SAVE
1006 spec->loopback.amplist = ad1986a_loopbacks;
1008 spec->vmaster_nid = 0x1b;
1010 codec->patch_ops = ad198x_patch_ops;
1012 /* override some parameters */
1013 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1016 switch (board_config) {
1017 case AD1986A_3STACK:
1018 spec->num_mixers = 2;
1019 spec->mixers[1] = ad1986a_3st_mixers;
1020 spec->num_init_verbs = 2;
1021 spec->init_verbs[1] = ad1986a_ch2_init;
1022 spec->channel_mode = ad1986a_modes;
1023 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1024 spec->need_dac_fix = 1;
1025 spec->multiout.max_channels = 2;
1026 spec->multiout.num_dacs = 1;
1028 case AD1986A_LAPTOP:
1029 spec->mixers[0] = ad1986a_laptop_mixers;
1030 spec->multiout.max_channels = 2;
1031 spec->multiout.num_dacs = 1;
1032 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1034 case AD1986A_LAPTOP_EAPD:
1035 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1036 spec->num_init_verbs = 3;
1037 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1038 spec->init_verbs[2] = ad1986a_automic_verbs;
1039 spec->multiout.max_channels = 2;
1040 spec->multiout.num_dacs = 1;
1041 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1042 if (!is_jack_available(codec, 0x25))
1043 spec->multiout.dig_out_nid = 0;
1044 spec->input_mux = &ad1986a_automic_capture_source;
1045 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1046 codec->patch_ops.init = ad1986a_automic_init;
1048 case AD1986A_LAPTOP_AUTOMUTE:
1049 spec->mixers[0] = ad1986a_laptop_automute_mixers;
1050 spec->num_init_verbs = 3;
1051 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1052 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1053 spec->multiout.max_channels = 2;
1054 spec->multiout.num_dacs = 1;
1055 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1056 if (!is_jack_available(codec, 0x25))
1057 spec->multiout.dig_out_nid = 0;
1058 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1059 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1060 codec->patch_ops.init = ad1986a_hp_init;
1063 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1064 spec->num_init_verbs = 2;
1065 spec->init_verbs[1] = ad1986a_ultra_init;
1066 spec->multiout.max_channels = 2;
1067 spec->multiout.num_dacs = 1;
1068 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1069 spec->multiout.dig_out_nid = 0;
1073 /* AD1986A has a hardware problem that it can't share a stream
1074 * with multiple output pins. The copy of front to surrounds
1075 * causes noisy or silent outputs at a certain timing, e.g.
1076 * changing the volume.
1077 * So, let's disable the shared stream.
1079 spec->multiout.no_share_stream = 1;
1088 #define AD1983_SPDIF_OUT 0x02
1089 #define AD1983_DAC 0x03
1090 #define AD1983_ADC 0x04
1092 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1093 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1094 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1096 static struct hda_input_mux ad1983_capture_source = {
1102 { "Mix Mono", 0x3 },
1107 * SPDIF playback route
1109 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1111 static char *texts[] = { "PCM", "ADC" };
1113 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1115 uinfo->value.enumerated.items = 2;
1116 if (uinfo->value.enumerated.item > 1)
1117 uinfo->value.enumerated.item = 1;
1118 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1122 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1124 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1125 struct ad198x_spec *spec = codec->spec;
1127 ucontrol->value.enumerated.item[0] = spec->spdif_route;
1131 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1133 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1134 struct ad198x_spec *spec = codec->spec;
1136 if (ucontrol->value.enumerated.item[0] > 1)
1138 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1139 spec->spdif_route = ucontrol->value.enumerated.item[0];
1140 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1141 AC_VERB_SET_CONNECT_SEL,
1148 static struct snd_kcontrol_new ad1983_mixers[] = {
1149 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1150 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1151 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1152 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1153 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1154 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1155 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1156 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1157 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1158 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1159 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1160 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1161 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT),
1162 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT),
1163 HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1164 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1165 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1167 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1168 .name = "Capture Source",
1169 .info = ad198x_mux_enum_info,
1170 .get = ad198x_mux_enum_get,
1171 .put = ad198x_mux_enum_put,
1174 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1175 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1176 .info = ad1983_spdif_route_info,
1177 .get = ad1983_spdif_route_get,
1178 .put = ad1983_spdif_route_put,
1183 static struct hda_verb ad1983_init_verbs[] = {
1184 /* Front, HP, Mono; mute as default */
1185 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1186 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1187 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1188 /* Beep, PCM, Mic, Line-In: mute */
1189 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1190 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1191 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1192 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1193 /* Front, HP selectors; from Mix */
1194 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1195 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1196 /* Mono selector; from Mix */
1197 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1198 /* Mic selector; Mic */
1199 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1200 /* Line-in selector: Line-in */
1201 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1202 /* Mic boost: 0dB */
1203 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1204 /* Record selector: mic */
1205 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1206 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1207 /* SPDIF route: PCM */
1208 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1210 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1212 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1214 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1216 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1218 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1222 #ifdef CONFIG_SND_HDA_POWER_SAVE
1223 static struct hda_amp_list ad1983_loopbacks[] = {
1224 { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1225 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1230 static int patch_ad1983(struct hda_codec *codec)
1232 struct ad198x_spec *spec;
1234 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1240 spec->multiout.max_channels = 2;
1241 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1242 spec->multiout.dac_nids = ad1983_dac_nids;
1243 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1244 spec->num_adc_nids = 1;
1245 spec->adc_nids = ad1983_adc_nids;
1246 spec->capsrc_nids = ad1983_capsrc_nids;
1247 spec->input_mux = &ad1983_capture_source;
1248 spec->num_mixers = 1;
1249 spec->mixers[0] = ad1983_mixers;
1250 spec->num_init_verbs = 1;
1251 spec->init_verbs[0] = ad1983_init_verbs;
1252 spec->spdif_route = 0;
1253 #ifdef CONFIG_SND_HDA_POWER_SAVE
1254 spec->loopback.amplist = ad1983_loopbacks;
1256 spec->vmaster_nid = 0x05;
1258 codec->patch_ops = ad198x_patch_ops;
1265 * AD1981 HD specific
1268 #define AD1981_SPDIF_OUT 0x02
1269 #define AD1981_DAC 0x03
1270 #define AD1981_ADC 0x04
1272 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1273 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1274 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1276 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1277 static struct hda_input_mux ad1981_capture_source = {
1280 { "Front Mic", 0x0 },
1283 { "Mix Mono", 0x3 },
1290 static struct snd_kcontrol_new ad1981_mixers[] = {
1291 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1292 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1293 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1294 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1295 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1296 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1297 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1298 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1299 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1300 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1301 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1302 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1303 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1304 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1305 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1306 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1307 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1308 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1309 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1310 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT),
1311 HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1312 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
1313 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1314 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1316 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1317 .name = "Capture Source",
1318 .info = ad198x_mux_enum_info,
1319 .get = ad198x_mux_enum_get,
1320 .put = ad198x_mux_enum_put,
1322 /* identical with AD1983 */
1324 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1325 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1326 .info = ad1983_spdif_route_info,
1327 .get = ad1983_spdif_route_get,
1328 .put = ad1983_spdif_route_put,
1333 static struct hda_verb ad1981_init_verbs[] = {
1334 /* Front, HP, Mono; mute as default */
1335 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1336 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1337 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1338 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1339 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1340 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1341 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1342 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1343 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1344 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1345 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1346 /* Front, HP selectors; from Mix */
1347 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1348 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1349 /* Mono selector; from Mix */
1350 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1351 /* Mic Mixer; select Front Mic */
1352 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1353 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1354 /* Mic boost: 0dB */
1355 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1356 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1357 /* Record selector: Front mic */
1358 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1359 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1360 /* SPDIF route: PCM */
1361 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1363 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1365 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1367 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1368 /* Front & Rear Mic Pins */
1369 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1370 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1372 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1374 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1375 /* Line-Out as Input: disabled */
1376 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1380 #ifdef CONFIG_SND_HDA_POWER_SAVE
1381 static struct hda_amp_list ad1981_loopbacks[] = {
1382 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1383 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1384 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1385 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1386 { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1392 * Patch for HP nx6320
1394 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1395 * speaker output enabled _and_ mute-LED off.
1398 #define AD1981_HP_EVENT 0x37
1399 #define AD1981_MIC_EVENT 0x38
1401 static struct hda_verb ad1981_hp_init_verbs[] = {
1402 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1403 /* pin sensing on HP and Mic jacks */
1404 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1405 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1409 /* turn on/off EAPD (+ mute HP) as a master switch */
1410 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1411 struct snd_ctl_elem_value *ucontrol)
1413 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1414 struct ad198x_spec *spec = codec->spec;
1416 if (! ad198x_eapd_put(kcontrol, ucontrol))
1418 /* change speaker pin appropriately */
1419 snd_hda_codec_write(codec, 0x05, 0,
1420 AC_VERB_SET_PIN_WIDGET_CONTROL,
1421 spec->cur_eapd ? PIN_OUT : 0);
1422 /* toggle HP mute appropriately */
1423 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1425 spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1429 /* bind volumes of both NID 0x05 and 0x06 */
1430 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1431 .ops = &snd_hda_bind_vol,
1433 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1434 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1439 /* mute internal speaker if HP is plugged */
1440 static void ad1981_hp_automute(struct hda_codec *codec)
1442 unsigned int present;
1444 present = snd_hda_codec_read(codec, 0x06, 0,
1445 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1446 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1447 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1450 /* toggle input of built-in and mic jack appropriately */
1451 static void ad1981_hp_automic(struct hda_codec *codec)
1453 static struct hda_verb mic_jack_on[] = {
1454 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1455 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1458 static struct hda_verb mic_jack_off[] = {
1459 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1460 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1463 unsigned int present;
1465 present = snd_hda_codec_read(codec, 0x08, 0,
1466 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1468 snd_hda_sequence_write(codec, mic_jack_on);
1470 snd_hda_sequence_write(codec, mic_jack_off);
1473 /* unsolicited event for HP jack sensing */
1474 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1479 case AD1981_HP_EVENT:
1480 ad1981_hp_automute(codec);
1482 case AD1981_MIC_EVENT:
1483 ad1981_hp_automic(codec);
1488 static struct hda_input_mux ad1981_hp_capture_source = {
1492 { "Docking-Station", 0x1 },
1497 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1498 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1500 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1501 .name = "Master Playback Switch",
1502 .info = ad198x_eapd_info,
1503 .get = ad198x_eapd_get,
1504 .put = ad1981_hp_master_sw_put,
1505 .private_value = 0x05,
1507 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1508 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1510 /* FIXME: analog mic/line loopback doesn't work with my tests...
1511 * (although recording is OK)
1513 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1514 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1515 HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1516 HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1517 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1518 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1519 /* FIXME: does this laptop have analog CD connection? */
1520 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1521 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1523 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1524 HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1525 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1526 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1528 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1529 .name = "Capture Source",
1530 .info = ad198x_mux_enum_info,
1531 .get = ad198x_mux_enum_get,
1532 .put = ad198x_mux_enum_put,
1537 /* initialize jack-sensing, too */
1538 static int ad1981_hp_init(struct hda_codec *codec)
1541 ad1981_hp_automute(codec);
1542 ad1981_hp_automic(codec);
1546 /* configuration for Toshiba Laptops */
1547 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1548 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1549 /* pin sensing on HP and Mic jacks */
1550 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1551 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1555 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1556 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1557 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1561 /* configuration for Lenovo Thinkpad T60 */
1562 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1563 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1564 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1565 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1566 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1567 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1568 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1569 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1570 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1571 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1572 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1573 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1575 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1576 .name = "Capture Source",
1577 .info = ad198x_mux_enum_info,
1578 .get = ad198x_mux_enum_get,
1579 .put = ad198x_mux_enum_put,
1581 /* identical with AD1983 */
1583 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1584 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1585 .info = ad1983_spdif_route_info,
1586 .get = ad1983_spdif_route_get,
1587 .put = ad1983_spdif_route_put,
1592 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1610 static const char *ad1981_models[AD1981_MODELS] = {
1612 [AD1981_THINKPAD] = "thinkpad",
1613 [AD1981_BASIC] = "basic",
1614 [AD1981_TOSHIBA] = "toshiba"
1617 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1618 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1620 SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
1621 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1622 /* Lenovo Thinkpad T60/X60/Z6xx */
1623 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
1624 /* HP nx6320 (reversed SSID, H/W bug) */
1625 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1629 static int patch_ad1981(struct hda_codec *codec)
1631 struct ad198x_spec *spec;
1634 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1640 spec->multiout.max_channels = 2;
1641 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1642 spec->multiout.dac_nids = ad1981_dac_nids;
1643 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1644 spec->num_adc_nids = 1;
1645 spec->adc_nids = ad1981_adc_nids;
1646 spec->capsrc_nids = ad1981_capsrc_nids;
1647 spec->input_mux = &ad1981_capture_source;
1648 spec->num_mixers = 1;
1649 spec->mixers[0] = ad1981_mixers;
1650 spec->num_init_verbs = 1;
1651 spec->init_verbs[0] = ad1981_init_verbs;
1652 spec->spdif_route = 0;
1653 #ifdef CONFIG_SND_HDA_POWER_SAVE
1654 spec->loopback.amplist = ad1981_loopbacks;
1656 spec->vmaster_nid = 0x05;
1658 codec->patch_ops = ad198x_patch_ops;
1660 /* override some parameters */
1661 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1664 switch (board_config) {
1666 spec->mixers[0] = ad1981_hp_mixers;
1667 spec->num_init_verbs = 2;
1668 spec->init_verbs[1] = ad1981_hp_init_verbs;
1669 spec->multiout.dig_out_nid = 0;
1670 spec->input_mux = &ad1981_hp_capture_source;
1672 codec->patch_ops.init = ad1981_hp_init;
1673 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1675 case AD1981_THINKPAD:
1676 spec->mixers[0] = ad1981_thinkpad_mixers;
1677 spec->input_mux = &ad1981_thinkpad_capture_source;
1679 case AD1981_TOSHIBA:
1680 spec->mixers[0] = ad1981_hp_mixers;
1681 spec->mixers[1] = ad1981_toshiba_mixers;
1682 spec->num_init_verbs = 2;
1683 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1684 spec->multiout.dig_out_nid = 0;
1685 spec->input_mux = &ad1981_hp_capture_source;
1686 codec->patch_ops.init = ad1981_hp_init;
1687 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1697 * Output pins and routes
1699 * Pin Mix Sel DAC (*)
1700 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1701 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1702 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
1703 * port-D 0x12 (mute/hp) <- 0x29 <- 04
1704 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1705 * port-F 0x16 (mute) <- 0x2a <- 06
1706 * port-G 0x24 (mute) <- 0x27 <- 05
1707 * port-H 0x25 (mute) <- 0x28 <- 0a
1708 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1710 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1711 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1713 * Input pins and routes
1715 * pin boost mix input # / adc input #
1716 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1717 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1718 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1719 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1720 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1721 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1722 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1723 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1727 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1728 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1730 * Inputs of Analog Mix (0x20)
1731 * 0:Port-B (front mic)
1732 * 1:Port-C/G/H (line-in)
1734 * 3:Port-D (line-in/2)
1735 * 4:Port-E/G/H (mic-in)
1736 * 5:Port-F (mic2-in)
1742 * 1:Port-B (front mic-in)
1743 * 2:Port-C (line-in)
1744 * 3:Port-F (mic2-in)
1749 * 8:Port-D (line-in/2)
1752 * Proposed pin assignments by the datasheet
1755 * Port-A front headphone
1765 * Port-A front headphone
1767 * C rear line-in/surround
1769 * E rear mic-in/CLFE
1775 * D internal speaker (with EAPD)
1776 * E/F quad mic array
1792 /* reivision id to check workarounds */
1793 #define AD1988A_REV2 0x100200
1795 #define is_rev2(codec) \
1796 ((codec)->vendor_id == 0x11d41988 && \
1797 (codec)->revision_id == AD1988A_REV2)
1803 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1804 0x04, 0x06, 0x05, 0x0a
1807 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1811 /* for AD1988A revision-2, DAC2-4 are swapped */
1812 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1813 0x04, 0x05, 0x0a, 0x06
1816 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1820 static hda_nid_t ad1988_adc_nids[3] = {
1824 static hda_nid_t ad1988_capsrc_nids[3] = {
1828 #define AD1988_SPDIF_OUT 0x02
1829 #define AD1988_SPDIF_IN 0x07
1831 static struct hda_input_mux ad1988_6stack_capture_source = {
1834 { "Front Mic", 0x1 }, /* port-B */
1835 { "Line", 0x2 }, /* port-C */
1836 { "Mic", 0x4 }, /* port-E */
1842 static struct hda_input_mux ad1988_laptop_capture_source = {
1845 { "Mic/Line", 0x1 }, /* port-B */
1853 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1854 struct snd_ctl_elem_info *uinfo)
1856 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1857 struct ad198x_spec *spec = codec->spec;
1858 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1859 spec->num_channel_mode);
1862 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
1863 struct snd_ctl_elem_value *ucontrol)
1865 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1866 struct ad198x_spec *spec = codec->spec;
1867 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
1868 spec->num_channel_mode, spec->multiout.max_channels);
1871 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
1872 struct snd_ctl_elem_value *ucontrol)
1874 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1875 struct ad198x_spec *spec = codec->spec;
1876 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
1877 spec->num_channel_mode,
1878 &spec->multiout.max_channels);
1879 if (err >= 0 && spec->need_dac_fix)
1880 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1885 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
1886 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1887 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1888 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1889 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1890 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1894 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
1895 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1896 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1897 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
1898 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
1899 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1903 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
1904 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1905 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
1906 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
1907 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
1908 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
1909 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1910 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1912 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1913 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1914 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1915 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1916 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1917 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1918 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1919 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1921 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1922 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1924 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1925 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1927 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1928 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1934 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
1935 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1936 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1937 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1938 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1942 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
1943 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1944 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1945 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
1946 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
1950 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
1951 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1952 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
1953 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
1954 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
1955 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1956 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1958 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1959 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1960 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1961 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1962 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1963 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1964 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1965 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1967 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1968 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1970 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1971 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1973 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1974 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1976 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1977 .name = "Channel Mode",
1978 .info = ad198x_ch_mode_info,
1979 .get = ad198x_ch_mode_get,
1980 .put = ad198x_ch_mode_put,
1987 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
1988 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1989 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
1990 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1992 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1993 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1994 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1995 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1996 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1997 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1999 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
2000 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2002 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2003 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2005 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2008 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2009 .name = "External Amplifier",
2010 .info = ad198x_eapd_info,
2011 .get = ad198x_eapd_get,
2012 .put = ad198x_eapd_put,
2013 .private_value = 0x12 | (1 << 8), /* port-D, inversed */
2020 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2021 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2022 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2023 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2024 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2025 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2026 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2028 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2029 /* The multiple "Capture Source" controls confuse alsamixer
2030 * So call somewhat different..
2032 /* .name = "Capture Source", */
2033 .name = "Input Source",
2035 .info = ad198x_mux_enum_info,
2036 .get = ad198x_mux_enum_get,
2037 .put = ad198x_mux_enum_put,
2042 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2043 struct snd_ctl_elem_info *uinfo)
2045 static char *texts[] = {
2046 "PCM", "ADC1", "ADC2", "ADC3"
2048 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2050 uinfo->value.enumerated.items = 4;
2051 if (uinfo->value.enumerated.item >= 4)
2052 uinfo->value.enumerated.item = 3;
2053 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2057 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2058 struct snd_ctl_elem_value *ucontrol)
2060 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2063 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2066 ucontrol->value.enumerated.item[0] = 0;
2068 sel = snd_hda_codec_read(codec, 0x0b, 0,
2069 AC_VERB_GET_CONNECT_SEL, 0);
2074 ucontrol->value.enumerated.item[0] = sel;
2079 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2080 struct snd_ctl_elem_value *ucontrol)
2082 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2083 unsigned int val, sel;
2086 val = ucontrol->value.enumerated.item[0];
2090 sel = snd_hda_codec_read(codec, 0x1d, 0,
2091 AC_VERB_GET_AMP_GAIN_MUTE,
2093 change = sel & 0x80;
2095 snd_hda_codec_write_cache(codec, 0x1d, 0,
2096 AC_VERB_SET_AMP_GAIN_MUTE,
2098 snd_hda_codec_write_cache(codec, 0x1d, 0,
2099 AC_VERB_SET_AMP_GAIN_MUTE,
2103 sel = snd_hda_codec_read(codec, 0x1d, 0,
2104 AC_VERB_GET_AMP_GAIN_MUTE,
2105 AC_AMP_GET_INPUT | 0x01);
2106 change = sel & 0x80;
2108 snd_hda_codec_write_cache(codec, 0x1d, 0,
2109 AC_VERB_SET_AMP_GAIN_MUTE,
2111 snd_hda_codec_write_cache(codec, 0x1d, 0,
2112 AC_VERB_SET_AMP_GAIN_MUTE,
2115 sel = snd_hda_codec_read(codec, 0x0b, 0,
2116 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2117 change |= sel != val;
2119 snd_hda_codec_write_cache(codec, 0x0b, 0,
2120 AC_VERB_SET_CONNECT_SEL,
2126 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2127 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2129 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2130 .name = "IEC958 Playback Source",
2131 .info = ad1988_spdif_playback_source_info,
2132 .get = ad1988_spdif_playback_source_get,
2133 .put = ad1988_spdif_playback_source_put,
2138 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2139 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2143 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2144 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2149 * initialization verbs
2153 * for 6-stack (+dig)
2155 static struct hda_verb ad1988_6stack_init_verbs[] = {
2156 /* Front, Surround, CLFE, side DAC; unmute as default */
2157 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2158 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2159 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2160 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2161 /* Port-A front headphon path */
2162 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2163 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2164 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2165 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2166 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2167 /* Port-D line-out path */
2168 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2169 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2170 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2171 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2172 /* Port-F surround path */
2173 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2174 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2175 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2176 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2177 /* Port-G CLFE path */
2178 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2179 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2180 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2181 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2182 /* Port-H side path */
2183 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2184 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2185 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2186 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2188 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2189 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2190 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2191 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2192 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2193 /* Port-B front mic-in path */
2194 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2195 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2196 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2197 /* Port-C line-in path */
2198 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2199 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2200 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2201 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2202 /* Port-E mic-in path */
2203 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2204 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2205 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2206 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2207 /* Analog CD Input */
2208 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2213 static struct hda_verb ad1988_capture_init_verbs[] = {
2214 /* mute analog mix */
2215 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2216 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2217 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2218 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2219 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2220 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2221 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2222 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2223 /* select ADCs - front-mic */
2224 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2225 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2226 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2228 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2229 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2230 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2235 static struct hda_verb ad1988_spdif_init_verbs[] = {
2237 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2238 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2239 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2240 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2242 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2247 /* AD1989 has no ADC -> SPDIF route */
2248 static struct hda_verb ad1989_spdif_init_verbs[] = {
2250 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2255 * verbs for 3stack (+dig)
2257 static struct hda_verb ad1988_3stack_ch2_init[] = {
2258 /* set port-C to line-in */
2259 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2260 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2261 /* set port-E to mic-in */
2262 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2263 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2267 static struct hda_verb ad1988_3stack_ch6_init[] = {
2268 /* set port-C to surround out */
2269 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2270 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2271 /* set port-E to CLFE out */
2272 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2273 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2277 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2278 { 2, ad1988_3stack_ch2_init },
2279 { 6, ad1988_3stack_ch6_init },
2282 static struct hda_verb ad1988_3stack_init_verbs[] = {
2283 /* Front, Surround, CLFE, side DAC; unmute as default */
2284 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2285 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2286 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2287 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2288 /* Port-A front headphon path */
2289 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2290 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2291 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2292 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2293 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2294 /* Port-D line-out path */
2295 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2296 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2297 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2298 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2300 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2301 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2302 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2303 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2304 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2305 /* Port-B front mic-in path */
2306 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2307 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2308 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2309 /* Port-C line-in/surround path - 6ch mode as default */
2310 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2311 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2312 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2313 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2314 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2315 /* Port-E mic-in/CLFE path - 6ch mode as default */
2316 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2317 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2318 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2319 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2320 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2321 /* mute analog mix */
2322 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2323 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2324 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2325 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2326 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2327 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2328 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2329 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2330 /* select ADCs - front-mic */
2331 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2332 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2333 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2335 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2336 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2337 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2342 * verbs for laptop mode (+dig)
2344 static struct hda_verb ad1988_laptop_hp_on[] = {
2345 /* unmute port-A and mute port-D */
2346 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2347 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2350 static struct hda_verb ad1988_laptop_hp_off[] = {
2351 /* mute port-A and unmute port-D */
2352 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2353 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2357 #define AD1988_HP_EVENT 0x01
2359 static struct hda_verb ad1988_laptop_init_verbs[] = {
2360 /* Front, Surround, CLFE, side DAC; unmute as default */
2361 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2362 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2363 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2364 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2365 /* Port-A front headphon path */
2366 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2367 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2368 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2369 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2370 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2371 /* unsolicited event for pin-sense */
2372 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2373 /* Port-D line-out path + EAPD */
2374 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2375 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2376 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2377 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2378 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2380 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2381 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2382 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2383 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2384 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2385 /* Port-B mic-in path */
2386 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2387 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2388 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2389 /* Port-C docking station - try to output */
2390 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2391 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2392 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2393 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2394 /* mute analog mix */
2395 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2396 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2397 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2398 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2399 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2400 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2401 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2402 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2403 /* select ADCs - mic */
2404 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2405 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2406 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2408 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2409 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2410 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2414 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2416 if ((res >> 26) != AD1988_HP_EVENT)
2418 if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
2419 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2421 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2424 #ifdef CONFIG_SND_HDA_POWER_SAVE
2425 static struct hda_amp_list ad1988_loopbacks[] = {
2426 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2427 { 0x20, HDA_INPUT, 1 }, /* Line */
2428 { 0x20, HDA_INPUT, 4 }, /* Mic */
2429 { 0x20, HDA_INPUT, 6 }, /* CD */
2435 * Automatic parse of I/O pins from the BIOS configuration
2438 #define NUM_CONTROL_ALLOC 32
2439 #define NUM_VERB_ALLOC 32
2446 static struct snd_kcontrol_new ad1988_control_templates[] = {
2447 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2448 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2449 HDA_BIND_MUTE(NULL, 0, 0, 0),
2452 /* add dynamic controls */
2453 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2456 struct snd_kcontrol_new *knew;
2458 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2459 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2461 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2464 if (spec->kctl_alloc) {
2465 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2466 kfree(spec->kctl_alloc);
2468 spec->kctl_alloc = knew;
2469 spec->num_kctl_alloc = num;
2472 knew = &spec->kctl_alloc[spec->num_kctl_used];
2473 *knew = ad1988_control_templates[type];
2474 knew->name = kstrdup(name, GFP_KERNEL);
2477 knew->private_value = val;
2478 spec->num_kctl_used++;
2482 #define AD1988_PIN_CD_NID 0x18
2483 #define AD1988_PIN_BEEP_NID 0x10
2485 static hda_nid_t ad1988_mixer_nids[8] = {
2486 /* A B C D E F G H */
2487 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2490 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2492 static hda_nid_t idx_to_dac[8] = {
2493 /* A B C D E F G H */
2494 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2496 static hda_nid_t idx_to_dac_rev2[8] = {
2497 /* A B C D E F G H */
2498 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2501 return idx_to_dac_rev2[idx];
2503 return idx_to_dac[idx];
2506 static hda_nid_t ad1988_boost_nids[8] = {
2507 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2510 static int ad1988_pin_idx(hda_nid_t nid)
2512 static hda_nid_t ad1988_io_pins[8] = {
2513 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2516 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2517 if (ad1988_io_pins[i] == nid)
2519 return 0; /* should be -1 */
2522 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2524 static int loopback_idx[8] = {
2525 2, 0, 1, 3, 4, 5, 1, 4
2528 case AD1988_PIN_CD_NID:
2531 return loopback_idx[ad1988_pin_idx(nid)];
2535 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2537 static int adc_idx[8] = {
2538 0, 1, 2, 8, 4, 3, 6, 7
2541 case AD1988_PIN_CD_NID:
2544 return adc_idx[ad1988_pin_idx(nid)];
2548 /* fill in the dac_nids table from the parsed pin configuration */
2549 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2550 const struct auto_pin_cfg *cfg)
2552 struct ad198x_spec *spec = codec->spec;
2555 spec->multiout.dac_nids = spec->private_dac_nids;
2557 /* check the pins hardwired to audio widget */
2558 for (i = 0; i < cfg->line_outs; i++) {
2559 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2560 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2562 spec->multiout.num_dacs = cfg->line_outs;
2566 /* add playback controls from the parsed DAC table */
2567 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2568 const struct auto_pin_cfg *cfg)
2571 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2575 for (i = 0; i < cfg->line_outs; i++) {
2576 hda_nid_t dac = spec->multiout.dac_nids[i];
2579 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2582 err = add_control(spec, AD_CTL_WIDGET_VOL,
2583 "Center Playback Volume",
2584 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2587 err = add_control(spec, AD_CTL_WIDGET_VOL,
2588 "LFE Playback Volume",
2589 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2592 err = add_control(spec, AD_CTL_BIND_MUTE,
2593 "Center Playback Switch",
2594 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2597 err = add_control(spec, AD_CTL_BIND_MUTE,
2598 "LFE Playback Switch",
2599 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2603 sprintf(name, "%s Playback Volume", chname[i]);
2604 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2605 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2608 sprintf(name, "%s Playback Switch", chname[i]);
2609 err = add_control(spec, AD_CTL_BIND_MUTE, name,
2610 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2618 /* add playback controls for speaker and HP outputs */
2619 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2622 struct ad198x_spec *spec = codec->spec;
2630 idx = ad1988_pin_idx(pin);
2631 nid = ad1988_idx_to_dac(codec, idx);
2632 /* check whether the corresponding DAC was already taken */
2633 for (i = 0; i < spec->autocfg.line_outs; i++) {
2634 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2635 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2639 if (i >= spec->autocfg.line_outs) {
2640 /* specify the DAC as the extra output */
2641 if (!spec->multiout.hp_nid)
2642 spec->multiout.hp_nid = nid;
2644 spec->multiout.extra_out_nid[0] = nid;
2645 /* control HP volume/switch on the output mixer amp */
2646 sprintf(name, "%s Playback Volume", pfx);
2647 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2648 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2652 nid = ad1988_mixer_nids[idx];
2653 sprintf(name, "%s Playback Switch", pfx);
2654 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2655 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2660 /* create input playback/capture controls for the given pin */
2661 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2662 const char *ctlname, int boost)
2667 sprintf(name, "%s Playback Volume", ctlname);
2668 idx = ad1988_pin_to_loopback_idx(pin);
2669 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2670 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2672 sprintf(name, "%s Playback Switch", ctlname);
2673 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2674 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2678 idx = ad1988_pin_idx(pin);
2679 bnid = ad1988_boost_nids[idx];
2681 sprintf(name, "%s Boost", ctlname);
2682 return add_control(spec, AD_CTL_WIDGET_VOL, name,
2683 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2690 /* create playback/capture controls for input pins */
2691 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2692 const struct auto_pin_cfg *cfg)
2694 struct hda_input_mux *imux = &spec->private_imux;
2697 for (i = 0; i < AUTO_PIN_LAST; i++) {
2698 err = new_analog_input(spec, cfg->input_pins[i],
2699 auto_pin_cfg_labels[i],
2700 i <= AUTO_PIN_FRONT_MIC);
2703 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2704 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2707 imux->items[imux->num_items].label = "Mix";
2708 imux->items[imux->num_items].index = 9;
2711 if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2712 "Analog Mix Playback Volume",
2713 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2715 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2716 "Analog Mix Playback Switch",
2717 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2723 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2724 hda_nid_t nid, int pin_type,
2728 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2729 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2731 case 0x11: /* port-A - DAC 04 */
2732 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2734 case 0x14: /* port-B - DAC 06 */
2735 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2737 case 0x15: /* port-C - DAC 05 */
2738 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2740 case 0x17: /* port-E - DAC 0a */
2741 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2743 case 0x13: /* mono - DAC 04 */
2744 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2749 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2751 struct ad198x_spec *spec = codec->spec;
2754 for (i = 0; i < spec->autocfg.line_outs; i++) {
2755 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2756 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2760 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2762 struct ad198x_spec *spec = codec->spec;
2765 pin = spec->autocfg.speaker_pins[0];
2766 if (pin) /* connect to front */
2767 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2768 pin = spec->autocfg.hp_pins[0];
2769 if (pin) /* connect to front */
2770 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2773 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2775 struct ad198x_spec *spec = codec->spec;
2778 for (i = 0; i < AUTO_PIN_LAST; i++) {
2779 hda_nid_t nid = spec->autocfg.input_pins[i];
2783 case 0x15: /* port-C */
2784 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2786 case 0x17: /* port-E */
2787 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2790 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2791 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2792 if (nid != AD1988_PIN_CD_NID)
2793 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2795 idx = ad1988_pin_idx(nid);
2796 if (ad1988_boost_nids[idx])
2797 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2798 AC_VERB_SET_AMP_GAIN_MUTE,
2803 /* parse the BIOS configuration and set up the alc_spec */
2804 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2805 static int ad1988_parse_auto_config(struct hda_codec *codec)
2807 struct ad198x_spec *spec = codec->spec;
2810 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2812 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2814 if (! spec->autocfg.line_outs)
2815 return 0; /* can't find valid BIOS pin config */
2816 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2817 (err = ad1988_auto_create_extra_out(codec,
2818 spec->autocfg.speaker_pins[0],
2820 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2821 "Headphone")) < 0 ||
2822 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2825 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2827 if (spec->autocfg.dig_out_pin)
2828 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2829 if (spec->autocfg.dig_in_pin)
2830 spec->dig_in_nid = AD1988_SPDIF_IN;
2832 if (spec->kctl_alloc)
2833 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2835 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2837 spec->input_mux = &spec->private_imux;
2842 /* init callback for auto-configuration model -- overriding the default init */
2843 static int ad1988_auto_init(struct hda_codec *codec)
2846 ad1988_auto_init_multi_out(codec);
2847 ad1988_auto_init_extra_out(codec);
2848 ad1988_auto_init_analog_input(codec);
2856 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2857 [AD1988_6STACK] = "6stack",
2858 [AD1988_6STACK_DIG] = "6stack-dig",
2859 [AD1988_3STACK] = "3stack",
2860 [AD1988_3STACK_DIG] = "3stack-dig",
2861 [AD1988_LAPTOP] = "laptop",
2862 [AD1988_LAPTOP_DIG] = "laptop-dig",
2863 [AD1988_AUTO] = "auto",
2866 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2867 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2868 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2869 SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
2873 static int patch_ad1988(struct hda_codec *codec)
2875 struct ad198x_spec *spec;
2878 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2885 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
2887 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
2888 ad1988_models, ad1988_cfg_tbl);
2889 if (board_config < 0) {
2890 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
2891 board_config = AD1988_AUTO;
2894 if (board_config == AD1988_AUTO) {
2895 /* automatic parse from the BIOS config */
2896 int err = ad1988_parse_auto_config(codec);
2901 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n");
2902 board_config = AD1988_6STACK;
2906 switch (board_config) {
2908 case AD1988_6STACK_DIG:
2909 spec->multiout.max_channels = 8;
2910 spec->multiout.num_dacs = 4;
2912 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
2914 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
2915 spec->input_mux = &ad1988_6stack_capture_source;
2916 spec->num_mixers = 2;
2918 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
2920 spec->mixers[0] = ad1988_6stack_mixers1;
2921 spec->mixers[1] = ad1988_6stack_mixers2;
2922 spec->num_init_verbs = 1;
2923 spec->init_verbs[0] = ad1988_6stack_init_verbs;
2924 if (board_config == AD1988_6STACK_DIG) {
2925 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2926 spec->dig_in_nid = AD1988_SPDIF_IN;
2930 case AD1988_3STACK_DIG:
2931 spec->multiout.max_channels = 6;
2932 spec->multiout.num_dacs = 3;
2934 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
2936 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2937 spec->input_mux = &ad1988_6stack_capture_source;
2938 spec->channel_mode = ad1988_3stack_modes;
2939 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
2940 spec->num_mixers = 2;
2942 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
2944 spec->mixers[0] = ad1988_3stack_mixers1;
2945 spec->mixers[1] = ad1988_3stack_mixers2;
2946 spec->num_init_verbs = 1;
2947 spec->init_verbs[0] = ad1988_3stack_init_verbs;
2948 if (board_config == AD1988_3STACK_DIG)
2949 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2952 case AD1988_LAPTOP_DIG:
2953 spec->multiout.max_channels = 2;
2954 spec->multiout.num_dacs = 1;
2955 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2956 spec->input_mux = &ad1988_laptop_capture_source;
2957 spec->num_mixers = 1;
2958 spec->mixers[0] = ad1988_laptop_mixers;
2959 spec->num_init_verbs = 1;
2960 spec->init_verbs[0] = ad1988_laptop_init_verbs;
2961 if (board_config == AD1988_LAPTOP_DIG)
2962 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2966 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
2967 spec->adc_nids = ad1988_adc_nids;
2968 spec->capsrc_nids = ad1988_capsrc_nids;
2969 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
2970 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
2971 if (spec->multiout.dig_out_nid) {
2972 if (codec->vendor_id >= 0x11d4989a) {
2973 spec->mixers[spec->num_mixers++] =
2974 ad1989_spdif_out_mixers;
2975 spec->init_verbs[spec->num_init_verbs++] =
2976 ad1989_spdif_init_verbs;
2978 spec->mixers[spec->num_mixers++] =
2979 ad1988_spdif_out_mixers;
2980 spec->init_verbs[spec->num_init_verbs++] =
2981 ad1988_spdif_init_verbs;
2984 if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a)
2985 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
2987 codec->patch_ops = ad198x_patch_ops;
2988 switch (board_config) {
2990 codec->patch_ops.init = ad1988_auto_init;
2993 case AD1988_LAPTOP_DIG:
2994 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
2997 #ifdef CONFIG_SND_HDA_POWER_SAVE
2998 spec->loopback.amplist = ad1988_loopbacks;
3000 spec->vmaster_nid = 0x04;
3009 * port-B - front line/mic-in
3010 * port-E - aux in/out
3011 * port-F - aux in/out
3012 * port-C - rear line/mic-in
3013 * port-D - rear line/hp-out
3014 * port-A - front line/hp-out
3016 * AD1984 = AD1884 + two digital mic-ins
3019 * For simplicity, we share the single DAC for both HP and line-outs
3020 * right now. The inidividual playbacks could be easily implemented,
3021 * but no build-up framework is given, so far.
3024 static hda_nid_t ad1884_dac_nids[1] = {
3028 static hda_nid_t ad1884_adc_nids[2] = {
3032 static hda_nid_t ad1884_capsrc_nids[2] = {
3036 #define AD1884_SPDIF_OUT 0x02
3038 static struct hda_input_mux ad1884_capture_source = {
3041 { "Front Mic", 0x0 },
3048 static struct snd_kcontrol_new ad1884_base_mixers[] = {
3049 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3050 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3051 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3052 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3053 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3054 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3055 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3056 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3057 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3058 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3059 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3060 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3062 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3063 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3064 HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
3065 HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
3067 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3068 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3069 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3070 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3071 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3072 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3074 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3075 /* The multiple "Capture Source" controls confuse alsamixer
3076 * So call somewhat different..
3078 /* .name = "Capture Source", */
3079 .name = "Input Source",
3081 .info = ad198x_mux_enum_info,
3082 .get = ad198x_mux_enum_get,
3083 .put = ad198x_mux_enum_put,
3085 /* SPDIF controls */
3086 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3088 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3089 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3090 /* identical with ad1983 */
3091 .info = ad1983_spdif_route_info,
3092 .get = ad1983_spdif_route_get,
3093 .put = ad1983_spdif_route_put,
3098 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3099 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3100 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3101 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3103 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3109 * initialization verbs
3111 static struct hda_verb ad1884_init_verbs[] = {
3112 /* DACs; mute as default */
3113 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3114 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3115 /* Port-A (HP) mixer */
3116 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3117 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3119 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3120 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3121 /* HP selector - select DAC2 */
3122 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3123 /* Port-D (Line-out) mixer */
3124 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3125 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3127 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3128 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3129 /* Mono-out mixer */
3130 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3131 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3133 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3134 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3136 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3137 /* Port-B (front mic) pin */
3138 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3139 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3140 /* Port-C (rear mic) pin */
3141 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3142 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3143 /* Analog mixer; mute as default */
3144 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3145 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3146 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3147 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3148 /* Analog Mix output amp */
3149 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3150 /* SPDIF output selector */
3151 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3152 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3156 #ifdef CONFIG_SND_HDA_POWER_SAVE
3157 static struct hda_amp_list ad1884_loopbacks[] = {
3158 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3159 { 0x20, HDA_INPUT, 1 }, /* Mic */
3160 { 0x20, HDA_INPUT, 2 }, /* CD */
3161 { 0x20, HDA_INPUT, 4 }, /* Docking */
3166 static const char *ad1884_slave_vols[] = {
3167 "PCM Playback Volume",
3168 "Mic Playback Volume",
3169 "Mono Playback Volume",
3170 "Front Mic Playback Volume",
3171 "Mic Playback Volume",
3172 "CD Playback Volume",
3173 "Internal Mic Playback Volume",
3174 "Docking Mic Playback Volume"
3175 "Beep Playback Volume",
3176 "IEC958 Playback Volume",
3180 static int patch_ad1884(struct hda_codec *codec)
3182 struct ad198x_spec *spec;
3184 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3190 spec->multiout.max_channels = 2;
3191 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3192 spec->multiout.dac_nids = ad1884_dac_nids;
3193 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3194 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3195 spec->adc_nids = ad1884_adc_nids;
3196 spec->capsrc_nids = ad1884_capsrc_nids;
3197 spec->input_mux = &ad1884_capture_source;
3198 spec->num_mixers = 1;
3199 spec->mixers[0] = ad1884_base_mixers;
3200 spec->num_init_verbs = 1;
3201 spec->init_verbs[0] = ad1884_init_verbs;
3202 spec->spdif_route = 0;
3203 #ifdef CONFIG_SND_HDA_POWER_SAVE
3204 spec->loopback.amplist = ad1884_loopbacks;
3206 spec->vmaster_nid = 0x04;
3207 /* we need to cover all playback volumes */
3208 spec->slave_vols = ad1884_slave_vols;
3210 codec->patch_ops = ad198x_patch_ops;
3216 * Lenovo Thinkpad T61/X61
3218 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3222 { "Internal Mic", 0x1 },
3224 { "Docking-Station", 0x4 },
3230 * Dell Precision T3400
3232 static struct hda_input_mux ad1984_dell_desktop_capture_source = {
3235 { "Front Mic", 0x0 },
3242 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3243 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3244 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3245 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3246 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3247 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3248 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3249 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3250 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3251 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3252 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3253 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3254 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3255 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3256 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3257 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3258 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3259 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3260 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3261 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3263 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3264 /* The multiple "Capture Source" controls confuse alsamixer
3265 * So call somewhat different..
3267 /* .name = "Capture Source", */
3268 .name = "Input Source",
3270 .info = ad198x_mux_enum_info,
3271 .get = ad198x_mux_enum_get,
3272 .put = ad198x_mux_enum_put,
3274 /* SPDIF controls */
3275 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3277 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3278 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3279 /* identical with ad1983 */
3280 .info = ad1983_spdif_route_info,
3281 .get = ad1983_spdif_route_get,
3282 .put = ad1983_spdif_route_put,
3287 /* additional verbs */
3288 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3289 /* Port-E (docking station mic) pin */
3290 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3291 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3292 /* docking mic boost */
3293 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3294 /* Analog mixer - docking mic; mute as default */
3295 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3296 /* enable EAPD bit */
3297 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3302 * Dell Precision T3400
3304 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3305 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3306 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3307 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3308 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3309 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3310 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3311 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3312 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3313 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3315 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3316 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3318 HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3319 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3320 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3321 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3322 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3323 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3325 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3326 /* The multiple "Capture Source" controls confuse alsamixer
3327 * So call somewhat different..
3329 /* .name = "Capture Source", */
3330 .name = "Input Source",
3332 .info = ad198x_mux_enum_info,
3333 .get = ad198x_mux_enum_get,
3334 .put = ad198x_mux_enum_put,
3339 /* Digial MIC ADC NID 0x05 + 0x06 */
3340 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3341 struct hda_codec *codec,
3342 unsigned int stream_tag,
3343 unsigned int format,
3344 struct snd_pcm_substream *substream)
3346 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3347 stream_tag, 0, format);
3351 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3352 struct hda_codec *codec,
3353 struct snd_pcm_substream *substream)
3355 snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number);
3359 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3365 .prepare = ad1984_pcm_dmic_prepare,
3366 .cleanup = ad1984_pcm_dmic_cleanup
3370 static int ad1984_build_pcms(struct hda_codec *codec)
3372 struct ad198x_spec *spec = codec->spec;
3373 struct hda_pcm *info;
3376 err = ad198x_build_pcms(codec);
3380 info = spec->pcm_rec + codec->num_pcms;
3382 info->name = "AD1984 Digital Mic";
3383 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3391 AD1984_DELL_DESKTOP,
3395 static const char *ad1984_models[AD1984_MODELS] = {
3396 [AD1984_BASIC] = "basic",
3397 [AD1984_THINKPAD] = "thinkpad",
3398 [AD1984_DELL_DESKTOP] = "dell_desktop",
3401 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3402 /* Lenovo Thinkpad T61/X61 */
3403 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1984_THINKPAD),
3404 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3408 static int patch_ad1984(struct hda_codec *codec)
3410 struct ad198x_spec *spec;
3411 int board_config, err;
3413 err = patch_ad1884(codec);
3417 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3418 ad1984_models, ad1984_cfg_tbl);
3419 switch (board_config) {
3421 /* additional digital mics */
3422 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3423 codec->patch_ops.build_pcms = ad1984_build_pcms;
3425 case AD1984_THINKPAD:
3426 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3427 spec->input_mux = &ad1984_thinkpad_capture_source;
3428 spec->mixers[0] = ad1984_thinkpad_mixers;
3429 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3431 case AD1984_DELL_DESKTOP:
3432 spec->multiout.dig_out_nid = 0;
3433 spec->input_mux = &ad1984_dell_desktop_capture_source;
3434 spec->mixers[0] = ad1984_dell_desktop_mixers;
3442 * AD1883 / AD1884A / AD1984A / AD1984B
3444 * port-B (0x14) - front mic-in
3445 * port-E (0x1c) - rear mic-in
3446 * port-F (0x16) - CD / ext out
3447 * port-C (0x15) - rear line-in
3448 * port-D (0x12) - rear line-out
3449 * port-A (0x11) - front hp-out
3451 * AD1984A = AD1884A + digital-mic
3452 * AD1883 = equivalent with AD1984A
3453 * AD1984B = AD1984A + extra SPDIF-out
3456 * We share the single DAC for both HP and line-outs (see AD1884/1984).
3459 static hda_nid_t ad1884a_dac_nids[1] = {
3463 #define ad1884a_adc_nids ad1884_adc_nids
3464 #define ad1884a_capsrc_nids ad1884_capsrc_nids
3466 #define AD1884A_SPDIF_OUT 0x02
3468 static struct hda_input_mux ad1884a_capture_source = {
3471 { "Front Mic", 0x0 },
3479 static struct snd_kcontrol_new ad1884a_base_mixers[] = {
3480 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3481 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3482 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3483 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3484 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3485 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3486 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3487 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3488 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3489 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3490 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
3491 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
3492 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3493 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3494 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3495 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3496 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3497 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3498 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3499 HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
3500 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3501 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3502 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3503 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3504 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3507 /* The multiple "Capture Source" controls confuse alsamixer
3508 * So call somewhat different..
3510 /* .name = "Capture Source", */
3511 .name = "Input Source",
3513 .info = ad198x_mux_enum_info,
3514 .get = ad198x_mux_enum_get,
3515 .put = ad198x_mux_enum_put,
3517 /* SPDIF controls */
3518 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3520 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3521 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3522 /* identical with ad1983 */
3523 .info = ad1983_spdif_route_info,
3524 .get = ad1983_spdif_route_get,
3525 .put = ad1983_spdif_route_put,
3531 * initialization verbs
3533 static struct hda_verb ad1884a_init_verbs[] = {
3534 /* DACs; unmute as default */
3535 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3536 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3537 /* Port-A (HP) mixer - route only from analog mixer */
3538 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3539 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3541 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3542 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3543 /* Port-D (Line-out) mixer - route only from analog mixer */
3544 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3545 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3547 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3548 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3549 /* Mono-out mixer - route only from analog mixer */
3550 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3551 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3553 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3554 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3555 /* Port-B (front mic) pin */
3556 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3557 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3558 /* Port-C (rear line-in) pin */
3559 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3560 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3561 /* Port-E (rear mic) pin */
3562 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3563 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3564 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
3565 /* Port-F (CD) pin */
3566 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3567 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3568 /* Analog mixer; mute as default */
3569 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3570 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3571 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3572 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3573 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
3574 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3575 /* Analog Mix output amp */
3576 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3577 /* capture sources */
3578 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
3579 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3580 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3581 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3582 /* SPDIF output amp */
3583 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3587 #ifdef CONFIG_SND_HDA_POWER_SAVE
3588 static struct hda_amp_list ad1884a_loopbacks[] = {
3589 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3590 { 0x20, HDA_INPUT, 1 }, /* Mic */
3591 { 0x20, HDA_INPUT, 2 }, /* CD */
3592 { 0x20, HDA_INPUT, 4 }, /* Docking */
3600 * Port A: Headphone jack
3602 * Port C: Internal MIC
3603 * Port D: Dock Line Out (if enabled)
3604 * Port E: Dock Line In (if enabled)
3605 * Port F: Internal speakers
3608 static struct hda_input_mux ad1884a_laptop_capture_source = {
3611 { "Mic", 0x0 }, /* port-B */
3612 { "Internal Mic", 0x1 }, /* port-C */
3613 { "Dock Mic", 0x4 }, /* port-E */
3618 static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
3619 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3620 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3621 HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3622 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3623 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3624 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3625 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3626 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3627 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3628 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3629 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3630 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3631 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3632 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3633 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3634 HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3635 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3636 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3637 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3638 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3640 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3641 /* The multiple "Capture Source" controls confuse alsamixer
3642 * So call somewhat different..
3644 /* .name = "Capture Source", */
3645 .name = "Input Source",
3647 .info = ad198x_mux_enum_info,
3648 .get = ad198x_mux_enum_get,
3649 .put = ad198x_mux_enum_put,
3654 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
3655 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3656 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3657 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3658 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3659 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3660 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3661 HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
3662 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
3663 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3664 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3668 /* mute internal speaker if HP is plugged */
3669 static void ad1884a_hp_automute(struct hda_codec *codec)
3671 unsigned int present;
3673 present = snd_hda_codec_read(codec, 0x11, 0,
3674 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
3675 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3676 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3677 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3678 present ? 0x00 : 0x02);
3681 /* switch to external mic if plugged */
3682 static void ad1884a_hp_automic(struct hda_codec *codec)
3684 unsigned int present;
3686 present = snd_hda_codec_read(codec, 0x14, 0,
3687 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
3688 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
3692 #define AD1884A_HP_EVENT 0x37
3693 #define AD1884A_MIC_EVENT 0x36
3695 /* unsolicited event for HP jack sensing */
3696 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
3698 switch (res >> 26) {
3699 case AD1884A_HP_EVENT:
3700 ad1884a_hp_automute(codec);
3702 case AD1884A_MIC_EVENT:
3703 ad1884a_hp_automic(codec);
3708 /* initialize jack-sensing, too */
3709 static int ad1884a_hp_init(struct hda_codec *codec)
3712 ad1884a_hp_automute(codec);
3713 ad1884a_hp_automic(codec);
3717 /* additional verbs for laptop model */
3718 static struct hda_verb ad1884a_laptop_verbs[] = {
3719 /* Port-A (HP) pin - always unmuted */
3720 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3721 /* Port-F (int speaker) mixer - route only from analog mixer */
3722 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3723 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3725 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3726 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3727 /* Port-C pin - internal mic-in */
3728 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3729 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3730 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3732 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3733 /* unsolicited event for pin-sense */
3734 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3735 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
3744 * 0x17 - built-in mic
3747 static struct hda_verb ad1984a_thinkpad_verbs[] = {
3749 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3751 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3753 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3754 /* unsolicited event for pin-sense */
3755 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3756 /* internal mic - dmic */
3757 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3758 /* set magic COEFs for dmic */
3759 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
3760 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
3764 static struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
3765 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3766 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3767 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3768 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3769 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3770 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3771 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3772 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3773 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3774 HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
3775 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3776 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3778 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3779 .name = "Capture Source",
3780 .info = ad198x_mux_enum_info,
3781 .get = ad198x_mux_enum_get,
3782 .put = ad198x_mux_enum_put,
3787 static struct hda_input_mux ad1984a_thinkpad_capture_source = {
3791 { "Internal Mic", 0x5 },
3796 /* mute internal speaker if HP is plugged */
3797 static void ad1984a_thinkpad_automute(struct hda_codec *codec)
3799 unsigned int present;
3801 present = snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0)
3802 & AC_PINSENSE_PRESENCE;
3803 snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
3804 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3807 /* unsolicited event for HP jack sensing */
3808 static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec,
3811 if ((res >> 26) != AD1884A_HP_EVENT)
3813 ad1984a_thinkpad_automute(codec);
3816 /* initialize jack-sensing, too */
3817 static int ad1984a_thinkpad_init(struct hda_codec *codec)
3820 ad1984a_thinkpad_automute(codec);
3835 static const char *ad1884a_models[AD1884A_MODELS] = {
3836 [AD1884A_DESKTOP] = "desktop",
3837 [AD1884A_LAPTOP] = "laptop",
3838 [AD1884A_MOBILE] = "mobile",
3839 [AD1884A_THINKPAD] = "thinkpad",
3842 static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
3843 SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
3844 SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
3848 static int patch_ad1884a(struct hda_codec *codec)
3850 struct ad198x_spec *spec;
3853 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3859 spec->multiout.max_channels = 2;
3860 spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
3861 spec->multiout.dac_nids = ad1884a_dac_nids;
3862 spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
3863 spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
3864 spec->adc_nids = ad1884a_adc_nids;
3865 spec->capsrc_nids = ad1884a_capsrc_nids;
3866 spec->input_mux = &ad1884a_capture_source;
3867 spec->num_mixers = 1;
3868 spec->mixers[0] = ad1884a_base_mixers;
3869 spec->num_init_verbs = 1;
3870 spec->init_verbs[0] = ad1884a_init_verbs;
3871 spec->spdif_route = 0;
3872 #ifdef CONFIG_SND_HDA_POWER_SAVE
3873 spec->loopback.amplist = ad1884a_loopbacks;
3875 codec->patch_ops = ad198x_patch_ops;
3877 /* override some parameters */
3878 board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
3881 switch (board_config) {
3882 case AD1884A_LAPTOP:
3883 spec->mixers[0] = ad1884a_laptop_mixers;
3884 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
3885 spec->multiout.dig_out_nid = 0;
3886 spec->input_mux = &ad1884a_laptop_capture_source;
3887 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
3888 codec->patch_ops.init = ad1884a_hp_init;
3890 case AD1884A_MOBILE:
3891 spec->mixers[0] = ad1884a_mobile_mixers;
3892 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
3893 spec->multiout.dig_out_nid = 0;
3894 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
3895 codec->patch_ops.init = ad1884a_hp_init;
3897 case AD1884A_THINKPAD:
3898 spec->mixers[0] = ad1984a_thinkpad_mixers;
3899 spec->init_verbs[spec->num_init_verbs++] =
3900 ad1984a_thinkpad_verbs;
3901 spec->multiout.dig_out_nid = 0;
3902 spec->input_mux = &ad1984a_thinkpad_capture_source;
3903 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
3904 codec->patch_ops.init = ad1984a_thinkpad_init;
3915 * port-A - front hp-out
3916 * port-B - front mic-in
3917 * port-C - rear line-in, shared surr-out (3stack)
3918 * port-D - rear line-out
3919 * port-E - rear mic-in, shared clfe-out (3stack)
3920 * port-F - rear surr-out (6stack)
3921 * port-G - rear clfe-out (6stack)
3924 static hda_nid_t ad1882_dac_nids[3] = {
3928 static hda_nid_t ad1882_adc_nids[2] = {
3932 static hda_nid_t ad1882_capsrc_nids[2] = {
3936 #define AD1882_SPDIF_OUT 0x02
3938 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
3939 static struct hda_input_mux ad1882_capture_source = {
3942 { "Front Mic", 0x1 },
3950 static struct snd_kcontrol_new ad1882_base_mixers[] = {
3951 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3952 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
3953 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
3954 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
3955 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3956 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3957 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3958 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3959 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3960 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3961 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3962 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3963 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
3964 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
3965 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
3966 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
3967 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
3968 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
3969 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
3970 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
3971 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
3972 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3973 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3974 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3975 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3977 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3978 /* The multiple "Capture Source" controls confuse alsamixer
3979 * So call somewhat different..
3981 /* .name = "Capture Source", */
3982 .name = "Input Source",
3984 .info = ad198x_mux_enum_info,
3985 .get = ad198x_mux_enum_get,
3986 .put = ad198x_mux_enum_put,
3988 /* SPDIF controls */
3989 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3991 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3992 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3993 /* identical with ad1983 */
3994 .info = ad1983_spdif_route_info,
3995 .get = ad1983_spdif_route_get,
3996 .put = ad1983_spdif_route_put,
4001 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
4002 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4003 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
4004 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
4006 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4007 .name = "Channel Mode",
4008 .info = ad198x_ch_mode_info,
4009 .get = ad198x_ch_mode_get,
4010 .put = ad198x_ch_mode_put,
4015 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
4016 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
4017 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
4018 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
4022 static struct hda_verb ad1882_ch2_init[] = {
4023 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4024 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4025 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4026 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4027 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4028 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4032 static struct hda_verb ad1882_ch4_init[] = {
4033 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4034 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4035 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4036 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4037 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4038 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4042 static struct hda_verb ad1882_ch6_init[] = {
4043 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4044 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4045 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4046 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4047 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4048 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4052 static struct hda_channel_mode ad1882_modes[3] = {
4053 { 2, ad1882_ch2_init },
4054 { 4, ad1882_ch4_init },
4055 { 6, ad1882_ch6_init },
4059 * initialization verbs
4061 static struct hda_verb ad1882_init_verbs[] = {
4062 /* DACs; mute as default */
4063 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4064 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4065 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4066 /* Port-A (HP) mixer */
4067 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4068 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4070 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4071 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4072 /* HP selector - select DAC2 */
4073 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
4074 /* Port-D (Line-out) mixer */
4075 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4076 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4078 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4079 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4080 /* Mono-out mixer */
4081 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4082 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4084 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4085 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4086 /* Port-B (front mic) pin */
4087 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4088 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4089 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4090 /* Port-C (line-in) pin */
4091 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4092 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4093 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4094 /* Port-C mixer - mute as input */
4095 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4096 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4097 /* Port-E (mic-in) pin */
4098 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4099 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4100 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4101 /* Port-E mixer - mute as input */
4102 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4103 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4104 /* Port-F (surround) */
4105 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4106 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4108 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4109 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4110 /* Analog mixer; mute as default */
4111 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
4112 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4113 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4114 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4115 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4116 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4117 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4118 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
4119 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4120 /* Analog Mix output amp */
4121 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
4122 /* SPDIF output selector */
4123 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4124 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
4125 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4129 #ifdef CONFIG_SND_HDA_POWER_SAVE
4130 static struct hda_amp_list ad1882_loopbacks[] = {
4131 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4132 { 0x20, HDA_INPUT, 1 }, /* Mic */
4133 { 0x20, HDA_INPUT, 4 }, /* Line */
4134 { 0x20, HDA_INPUT, 6 }, /* CD */
4146 static const char *ad1882_models[AD1986A_MODELS] = {
4147 [AD1882_3STACK] = "3stack",
4148 [AD1882_6STACK] = "6stack",
4152 static int patch_ad1882(struct hda_codec *codec)
4154 struct ad198x_spec *spec;
4157 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4163 spec->multiout.max_channels = 6;
4164 spec->multiout.num_dacs = 3;
4165 spec->multiout.dac_nids = ad1882_dac_nids;
4166 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
4167 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
4168 spec->adc_nids = ad1882_adc_nids;
4169 spec->capsrc_nids = ad1882_capsrc_nids;
4170 spec->input_mux = &ad1882_capture_source;
4171 spec->num_mixers = 1;
4172 spec->mixers[0] = ad1882_base_mixers;
4173 spec->num_init_verbs = 1;
4174 spec->init_verbs[0] = ad1882_init_verbs;
4175 spec->spdif_route = 0;
4176 #ifdef CONFIG_SND_HDA_POWER_SAVE
4177 spec->loopback.amplist = ad1882_loopbacks;
4179 spec->vmaster_nid = 0x04;
4181 codec->patch_ops = ad198x_patch_ops;
4183 /* override some parameters */
4184 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
4185 ad1882_models, NULL);
4186 switch (board_config) {
4189 spec->num_mixers = 2;
4190 spec->mixers[1] = ad1882_3stack_mixers;
4191 spec->channel_mode = ad1882_modes;
4192 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
4193 spec->need_dac_fix = 1;
4194 spec->multiout.max_channels = 2;
4195 spec->multiout.num_dacs = 1;
4198 spec->num_mixers = 2;
4199 spec->mixers[1] = ad1882_6stack_mixers;
4209 struct hda_codec_preset snd_hda_preset_analog[] = {
4210 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
4211 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
4212 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
4213 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
4214 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
4215 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
4216 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
4217 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
4218 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
4219 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
4220 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
4221 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
4222 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },
4223 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },