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>
26 #include <linux/mutex.h>
28 #include <sound/core.h>
29 #include "hda_codec.h"
30 #include "hda_local.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 struct mutex amp_mutex; /* PCM volume/mute control mutex */
67 unsigned int spdif_route;
69 /* dynamic controls, init_verbs and input_mux */
70 struct auto_pin_cfg autocfg;
71 unsigned int num_kctl_alloc, num_kctl_used;
72 struct snd_kcontrol_new *kctl_alloc;
73 struct hda_input_mux private_imux;
74 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
76 unsigned int jack_present :1;
78 #ifdef CONFIG_SND_HDA_POWER_SAVE
79 struct hda_loopback_check loopback;
81 /* for virtual master */
82 hda_nid_t vmaster_nid;
84 const char **slave_vols;
85 const char **slave_sws;
89 * input MUX handling (common part)
91 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
93 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
94 struct ad198x_spec *spec = codec->spec;
96 return snd_hda_input_mux_info(spec->input_mux, uinfo);
99 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
101 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
102 struct ad198x_spec *spec = codec->spec;
103 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
105 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
109 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
111 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
112 struct ad198x_spec *spec = codec->spec;
113 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
115 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
116 spec->capsrc_nids[adc_idx],
117 &spec->cur_mux[adc_idx]);
121 * initialization (common callbacks)
123 static int ad198x_init(struct hda_codec *codec)
125 struct ad198x_spec *spec = codec->spec;
128 for (i = 0; i < spec->num_init_verbs; i++)
129 snd_hda_sequence_write(codec, spec->init_verbs[i]);
133 static const char *ad_slave_vols[] = {
134 "Front Playback Volume",
135 "Surround Playback Volume",
136 "Center Playback Volume",
137 "LFE Playback Volume",
138 "Side Playback Volume",
139 "Headphone Playback Volume",
140 "Mono Playback Volume",
141 "Speaker Playback Volume",
142 "IEC958 Playback Volume",
146 static const char *ad_slave_sws[] = {
147 "Front Playback Switch",
148 "Surround Playback Switch",
149 "Center Playback Switch",
150 "LFE Playback Switch",
151 "Side Playback Switch",
152 "Headphone Playback Switch",
153 "Mono Playback Switch",
154 "Speaker Playback Switch",
155 "IEC958 Playback Switch",
159 static int ad198x_build_controls(struct hda_codec *codec)
161 struct ad198x_spec *spec = codec->spec;
165 for (i = 0; i < spec->num_mixers; i++) {
166 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
170 if (spec->multiout.dig_out_nid) {
171 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
174 err = snd_hda_create_spdif_share_sw(codec,
178 spec->multiout.share_spdif = 1;
180 if (spec->dig_in_nid) {
181 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
186 /* if we have no master control, let's create it */
187 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
188 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
189 HDA_OUTPUT, spec->vmaster_tlv);
190 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
193 spec->slave_vols : ad_slave_vols));
197 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
198 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
201 spec->slave_sws : ad_slave_sws));
209 #ifdef CONFIG_SND_HDA_POWER_SAVE
210 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
212 struct ad198x_spec *spec = codec->spec;
213 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
218 * Analog playback callbacks
220 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
221 struct hda_codec *codec,
222 struct snd_pcm_substream *substream)
224 struct ad198x_spec *spec = codec->spec;
225 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
229 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
230 struct hda_codec *codec,
231 unsigned int stream_tag,
233 struct snd_pcm_substream *substream)
235 struct ad198x_spec *spec = codec->spec;
236 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
240 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
241 struct hda_codec *codec,
242 struct snd_pcm_substream *substream)
244 struct ad198x_spec *spec = codec->spec;
245 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
251 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
252 struct hda_codec *codec,
253 struct snd_pcm_substream *substream)
255 struct ad198x_spec *spec = codec->spec;
256 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
259 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
260 struct hda_codec *codec,
261 struct snd_pcm_substream *substream)
263 struct ad198x_spec *spec = codec->spec;
264 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
267 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
268 struct hda_codec *codec,
269 unsigned int stream_tag,
271 struct snd_pcm_substream *substream)
273 struct ad198x_spec *spec = codec->spec;
274 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
281 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
282 struct hda_codec *codec,
283 unsigned int stream_tag,
285 struct snd_pcm_substream *substream)
287 struct ad198x_spec *spec = codec->spec;
288 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
289 stream_tag, 0, format);
293 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
294 struct hda_codec *codec,
295 struct snd_pcm_substream *substream)
297 struct ad198x_spec *spec = codec->spec;
298 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
306 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
309 .channels_max = 6, /* changed later */
310 .nid = 0, /* fill later */
312 .open = ad198x_playback_pcm_open,
313 .prepare = ad198x_playback_pcm_prepare,
314 .cleanup = ad198x_playback_pcm_cleanup
318 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
322 .nid = 0, /* fill later */
324 .prepare = ad198x_capture_pcm_prepare,
325 .cleanup = ad198x_capture_pcm_cleanup
329 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
333 .nid = 0, /* fill later */
335 .open = ad198x_dig_playback_pcm_open,
336 .close = ad198x_dig_playback_pcm_close,
337 .prepare = ad198x_dig_playback_pcm_prepare
341 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
345 /* NID is set in alc_build_pcms */
348 static int ad198x_build_pcms(struct hda_codec *codec)
350 struct ad198x_spec *spec = codec->spec;
351 struct hda_pcm *info = spec->pcm_rec;
354 codec->pcm_info = info;
356 info->name = "AD198x Analog";
357 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
358 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
359 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
360 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
361 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
362 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
364 if (spec->multiout.dig_out_nid) {
367 info->name = "AD198x Digital";
368 info->pcm_type = HDA_PCM_TYPE_SPDIF;
369 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
370 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
371 if (spec->dig_in_nid) {
372 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
373 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
380 static void ad198x_free(struct hda_codec *codec)
382 struct ad198x_spec *spec = codec->spec;
385 if (spec->kctl_alloc) {
386 for (i = 0; i < spec->num_kctl_used; i++)
387 kfree(spec->kctl_alloc[i].name);
388 kfree(spec->kctl_alloc);
393 static struct hda_codec_ops ad198x_patch_ops = {
394 .build_controls = ad198x_build_controls,
395 .build_pcms = ad198x_build_pcms,
398 #ifdef CONFIG_SND_HDA_POWER_SAVE
399 .check_power_status = ad198x_check_power_status,
406 * the private value = nid | (invert << 8)
408 #define ad198x_eapd_info snd_ctl_boolean_mono_info
410 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
411 struct snd_ctl_elem_value *ucontrol)
413 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
414 struct ad198x_spec *spec = codec->spec;
415 int invert = (kcontrol->private_value >> 8) & 1;
417 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
419 ucontrol->value.integer.value[0] = spec->cur_eapd;
423 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
424 struct snd_ctl_elem_value *ucontrol)
426 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
427 struct ad198x_spec *spec = codec->spec;
428 int invert = (kcontrol->private_value >> 8) & 1;
429 hda_nid_t nid = kcontrol->private_value & 0xff;
431 eapd = !!ucontrol->value.integer.value[0];
434 if (eapd == spec->cur_eapd)
436 spec->cur_eapd = eapd;
437 snd_hda_codec_write_cache(codec, nid,
438 0, AC_VERB_SET_EAPD_BTLENABLE,
443 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
444 struct snd_ctl_elem_info *uinfo);
445 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
446 struct snd_ctl_elem_value *ucontrol);
447 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
448 struct snd_ctl_elem_value *ucontrol);
455 #define AD1986A_SPDIF_OUT 0x02
456 #define AD1986A_FRONT_DAC 0x03
457 #define AD1986A_SURR_DAC 0x04
458 #define AD1986A_CLFE_DAC 0x05
459 #define AD1986A_ADC 0x06
461 static hda_nid_t ad1986a_dac_nids[3] = {
462 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
464 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
465 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
467 static struct hda_input_mux ad1986a_capture_source = {
481 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
482 .ops = &snd_hda_bind_vol,
484 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
485 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
486 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
491 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
492 .ops = &snd_hda_bind_sw,
494 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
495 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
496 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
504 static struct snd_kcontrol_new ad1986a_mixers[] = {
506 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
508 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
509 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
510 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
511 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
512 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
513 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
514 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
515 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
516 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
517 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
518 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
519 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
520 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
521 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
522 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
523 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
524 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
525 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
526 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
527 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
528 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
529 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
530 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
531 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
532 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
533 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
534 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
536 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
537 .name = "Capture Source",
538 .info = ad198x_mux_enum_info,
539 .get = ad198x_mux_enum_get,
540 .put = ad198x_mux_enum_put,
542 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
546 /* additional mixers for 3stack mode */
547 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
549 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
550 .name = "Channel Mode",
551 .info = ad198x_ch_mode_info,
552 .get = ad198x_ch_mode_get,
553 .put = ad198x_ch_mode_put,
558 /* laptop model - 2ch only */
559 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
561 /* master controls both pins 0x1a and 0x1b */
562 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
563 .ops = &snd_hda_bind_vol,
565 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
566 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
571 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
572 .ops = &snd_hda_bind_sw,
574 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
575 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
580 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
581 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
582 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
583 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
584 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
585 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
586 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
587 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
588 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
589 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
590 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
591 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
592 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
593 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
594 /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
595 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
596 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
597 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
598 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
599 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
601 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
602 .name = "Capture Source",
603 .info = ad198x_mux_enum_info,
604 .get = ad198x_mux_enum_get,
605 .put = ad198x_mux_enum_put,
610 /* laptop-eapd model - 2ch only */
612 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
616 { "Internal Mic", 0x4 },
621 static struct hda_input_mux ad1986a_automic_capture_source = {
629 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
630 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
631 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
632 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
633 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
634 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
635 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
636 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
637 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
638 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
640 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
641 .name = "Capture Source",
642 .info = ad198x_mux_enum_info,
643 .get = ad198x_mux_enum_get,
644 .put = ad198x_mux_enum_put,
647 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
648 .name = "External Amplifier",
649 .info = ad198x_eapd_info,
650 .get = ad198x_eapd_get,
651 .put = ad198x_eapd_put,
652 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
657 /* re-connect the mic boost input according to the jack sensing */
658 static void ad1986a_automic(struct hda_codec *codec)
660 unsigned int present;
661 present = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_PIN_SENSE, 0);
662 /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
663 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
664 (present & AC_PINSENSE_PRESENCE) ? 0 : 2);
667 #define AD1986A_MIC_EVENT 0x36
669 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
672 if ((res >> 26) != AD1986A_MIC_EVENT)
674 ad1986a_automic(codec);
677 static int ad1986a_automic_init(struct hda_codec *codec)
680 ad1986a_automic(codec);
684 /* laptop-automute - 2ch only */
686 static void ad1986a_update_hp(struct hda_codec *codec)
688 struct ad198x_spec *spec = codec->spec;
691 if (spec->jack_present)
692 mute = HDA_AMP_MUTE; /* mute internal speaker */
694 /* unmute internal speaker if necessary */
695 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
696 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
700 static void ad1986a_hp_automute(struct hda_codec *codec)
702 struct ad198x_spec *spec = codec->spec;
703 unsigned int present;
705 present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
706 /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
707 spec->jack_present = !(present & 0x80000000);
708 ad1986a_update_hp(codec);
711 #define AD1986A_HP_EVENT 0x37
713 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
715 if ((res >> 26) != AD1986A_HP_EVENT)
717 ad1986a_hp_automute(codec);
720 static int ad1986a_hp_init(struct hda_codec *codec)
723 ad1986a_hp_automute(codec);
727 /* bind hp and internal speaker mute (with plug check) */
728 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
729 struct snd_ctl_elem_value *ucontrol)
731 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
732 long *valp = ucontrol->value.integer.value;
735 change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
737 valp[0] ? 0 : HDA_AMP_MUTE);
738 change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
740 valp[1] ? 0 : HDA_AMP_MUTE);
742 ad1986a_update_hp(codec);
746 static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
747 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
749 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
750 .name = "Master Playback Switch",
751 .info = snd_hda_mixer_amp_switch_info,
752 .get = snd_hda_mixer_amp_switch_get,
753 .put = ad1986a_hp_master_sw_put,
754 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
756 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
757 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
758 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
759 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
760 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
761 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
762 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
763 HDA_CODEC_VOLUME("Beep Playback Volume", 0x18, 0x0, HDA_OUTPUT),
764 HDA_CODEC_MUTE("Beep Playback Switch", 0x18, 0x0, HDA_OUTPUT),
765 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
766 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
768 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
769 .name = "Capture Source",
770 .info = ad198x_mux_enum_info,
771 .get = ad198x_mux_enum_get,
772 .put = ad198x_mux_enum_put,
775 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
776 .name = "External Amplifier",
777 .info = ad198x_eapd_info,
778 .get = ad198x_eapd_get,
779 .put = ad198x_eapd_put,
780 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
786 * initialization verbs
788 static struct hda_verb ad1986a_init_verbs[] = {
789 /* Front, Surround, CLFE DAC; mute as default */
790 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
791 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
792 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
794 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
795 /* HP, Line-Out, Surround, CLFE selectors */
796 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
797 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
798 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
799 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
801 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
802 /* Mic selector: Mic 1/2 pin */
803 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
804 /* Line-in selector: Line-in */
805 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
807 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
808 /* Record selector: mic */
809 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
810 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
811 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
812 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
813 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
814 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
815 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
817 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
818 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
819 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
820 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
821 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
822 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
823 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
825 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
826 /* Front, Surround, CLFE Pins */
827 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
828 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
829 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
831 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
833 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
834 /* Line, Aux, CD, Beep-In Pin */
835 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
836 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
837 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
838 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
839 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
843 static struct hda_verb ad1986a_ch2_init[] = {
844 /* Surround out -> Line In */
845 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
846 /* Line-in selectors */
847 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
849 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
850 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
851 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
855 static struct hda_verb ad1986a_ch4_init[] = {
856 /* Surround out -> Surround */
857 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
858 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
860 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
861 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
865 static struct hda_verb ad1986a_ch6_init[] = {
866 /* Surround out -> Surround out */
867 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
868 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
870 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
871 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
875 static struct hda_channel_mode ad1986a_modes[3] = {
876 { 2, ad1986a_ch2_init },
877 { 4, ad1986a_ch4_init },
878 { 6, ad1986a_ch6_init },
881 /* eapd initialization */
882 static struct hda_verb ad1986a_eapd_init_verbs[] = {
883 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
887 static struct hda_verb ad1986a_automic_verbs[] = {
888 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
889 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
890 /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
891 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
892 {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
896 /* Ultra initialization */
897 static struct hda_verb ad1986a_ultra_init[] = {
898 /* eapd initialization */
899 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
901 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
902 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
903 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
907 /* pin sensing on HP jack */
908 static struct hda_verb ad1986a_hp_init_verbs[] = {
909 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
920 AD1986A_LAPTOP_AUTOMUTE,
925 static const char *ad1986a_models[AD1986A_MODELS] = {
926 [AD1986A_6STACK] = "6stack",
927 [AD1986A_3STACK] = "3stack",
928 [AD1986A_LAPTOP] = "laptop",
929 [AD1986A_LAPTOP_EAPD] = "laptop-eapd",
930 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
931 [AD1986A_ULTRA] = "ultra",
934 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
935 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
936 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
937 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
938 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
939 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
940 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
941 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
942 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
943 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
944 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
945 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
946 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
947 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
948 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
949 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
950 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
951 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
952 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
953 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
954 SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_LAPTOP_EAPD),
955 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_LAPTOP_EAPD),
956 SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_LAPTOP_EAPD),
957 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
958 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
959 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
960 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
961 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
962 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
966 #ifdef CONFIG_SND_HDA_POWER_SAVE
967 static struct hda_amp_list ad1986a_loopbacks[] = {
968 { 0x13, HDA_OUTPUT, 0 }, /* Mic */
969 { 0x14, HDA_OUTPUT, 0 }, /* Phone */
970 { 0x15, HDA_OUTPUT, 0 }, /* CD */
971 { 0x16, HDA_OUTPUT, 0 }, /* Aux */
972 { 0x17, HDA_OUTPUT, 0 }, /* Line */
977 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
979 unsigned int conf = snd_hda_codec_read(codec, nid, 0,
980 AC_VERB_GET_CONFIG_DEFAULT, 0);
981 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
984 static int patch_ad1986a(struct hda_codec *codec)
986 struct ad198x_spec *spec;
989 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
995 spec->multiout.max_channels = 6;
996 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
997 spec->multiout.dac_nids = ad1986a_dac_nids;
998 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
999 spec->num_adc_nids = 1;
1000 spec->adc_nids = ad1986a_adc_nids;
1001 spec->capsrc_nids = ad1986a_capsrc_nids;
1002 spec->input_mux = &ad1986a_capture_source;
1003 spec->num_mixers = 1;
1004 spec->mixers[0] = ad1986a_mixers;
1005 spec->num_init_verbs = 1;
1006 spec->init_verbs[0] = ad1986a_init_verbs;
1007 #ifdef CONFIG_SND_HDA_POWER_SAVE
1008 spec->loopback.amplist = ad1986a_loopbacks;
1010 spec->vmaster_nid = 0x1b;
1012 codec->patch_ops = ad198x_patch_ops;
1014 /* override some parameters */
1015 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1018 switch (board_config) {
1019 case AD1986A_3STACK:
1020 spec->num_mixers = 2;
1021 spec->mixers[1] = ad1986a_3st_mixers;
1022 spec->num_init_verbs = 2;
1023 spec->init_verbs[1] = ad1986a_ch2_init;
1024 spec->channel_mode = ad1986a_modes;
1025 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1026 spec->need_dac_fix = 1;
1027 spec->multiout.max_channels = 2;
1028 spec->multiout.num_dacs = 1;
1030 case AD1986A_LAPTOP:
1031 spec->mixers[0] = ad1986a_laptop_mixers;
1032 spec->multiout.max_channels = 2;
1033 spec->multiout.num_dacs = 1;
1034 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1036 case AD1986A_LAPTOP_EAPD:
1037 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1038 spec->num_init_verbs = 3;
1039 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1040 spec->init_verbs[2] = ad1986a_automic_verbs;
1041 spec->multiout.max_channels = 2;
1042 spec->multiout.num_dacs = 1;
1043 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1044 if (!is_jack_available(codec, 0x25))
1045 spec->multiout.dig_out_nid = 0;
1046 spec->input_mux = &ad1986a_automic_capture_source;
1047 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1048 codec->patch_ops.init = ad1986a_automic_init;
1050 case AD1986A_LAPTOP_AUTOMUTE:
1051 spec->mixers[0] = ad1986a_laptop_automute_mixers;
1052 spec->num_init_verbs = 3;
1053 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1054 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1055 spec->multiout.max_channels = 2;
1056 spec->multiout.num_dacs = 1;
1057 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1058 if (!is_jack_available(codec, 0x25))
1059 spec->multiout.dig_out_nid = 0;
1060 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1061 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1062 codec->patch_ops.init = ad1986a_hp_init;
1065 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1066 spec->num_init_verbs = 2;
1067 spec->init_verbs[1] = ad1986a_ultra_init;
1068 spec->multiout.max_channels = 2;
1069 spec->multiout.num_dacs = 1;
1070 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1071 spec->multiout.dig_out_nid = 0;
1075 /* AD1986A has a hardware problem that it can't share a stream
1076 * with multiple output pins. The copy of front to surrounds
1077 * causes noisy or silent outputs at a certain timing, e.g.
1078 * changing the volume.
1079 * So, let's disable the shared stream.
1081 spec->multiout.no_share_stream = 1;
1090 #define AD1983_SPDIF_OUT 0x02
1091 #define AD1983_DAC 0x03
1092 #define AD1983_ADC 0x04
1094 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1095 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1096 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1098 static struct hda_input_mux ad1983_capture_source = {
1104 { "Mix Mono", 0x3 },
1109 * SPDIF playback route
1111 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1113 static char *texts[] = { "PCM", "ADC" };
1115 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1117 uinfo->value.enumerated.items = 2;
1118 if (uinfo->value.enumerated.item > 1)
1119 uinfo->value.enumerated.item = 1;
1120 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1124 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1126 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1127 struct ad198x_spec *spec = codec->spec;
1129 ucontrol->value.enumerated.item[0] = spec->spdif_route;
1133 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1135 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1136 struct ad198x_spec *spec = codec->spec;
1138 if (ucontrol->value.enumerated.item[0] > 1)
1140 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1141 spec->spdif_route = ucontrol->value.enumerated.item[0];
1142 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1143 AC_VERB_SET_CONNECT_SEL,
1150 static struct snd_kcontrol_new ad1983_mixers[] = {
1151 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1152 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1153 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1154 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1155 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1156 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1157 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1158 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1159 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1160 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1161 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1162 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1163 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT),
1164 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT),
1165 HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1166 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1167 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1169 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1170 .name = "Capture Source",
1171 .info = ad198x_mux_enum_info,
1172 .get = ad198x_mux_enum_get,
1173 .put = ad198x_mux_enum_put,
1176 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1177 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1178 .info = ad1983_spdif_route_info,
1179 .get = ad1983_spdif_route_get,
1180 .put = ad1983_spdif_route_put,
1185 static struct hda_verb ad1983_init_verbs[] = {
1186 /* Front, HP, Mono; mute as default */
1187 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1188 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1189 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1190 /* Beep, PCM, Mic, Line-In: mute */
1191 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1192 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1193 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1194 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1195 /* Front, HP selectors; from Mix */
1196 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1197 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1198 /* Mono selector; from Mix */
1199 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1200 /* Mic selector; Mic */
1201 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1202 /* Line-in selector: Line-in */
1203 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1204 /* Mic boost: 0dB */
1205 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1206 /* Record selector: mic */
1207 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1208 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1209 /* SPDIF route: PCM */
1210 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1212 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1214 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1216 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1218 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1220 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1224 #ifdef CONFIG_SND_HDA_POWER_SAVE
1225 static struct hda_amp_list ad1983_loopbacks[] = {
1226 { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1227 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1232 static int patch_ad1983(struct hda_codec *codec)
1234 struct ad198x_spec *spec;
1236 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1242 spec->multiout.max_channels = 2;
1243 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1244 spec->multiout.dac_nids = ad1983_dac_nids;
1245 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1246 spec->num_adc_nids = 1;
1247 spec->adc_nids = ad1983_adc_nids;
1248 spec->capsrc_nids = ad1983_capsrc_nids;
1249 spec->input_mux = &ad1983_capture_source;
1250 spec->num_mixers = 1;
1251 spec->mixers[0] = ad1983_mixers;
1252 spec->num_init_verbs = 1;
1253 spec->init_verbs[0] = ad1983_init_verbs;
1254 spec->spdif_route = 0;
1255 #ifdef CONFIG_SND_HDA_POWER_SAVE
1256 spec->loopback.amplist = ad1983_loopbacks;
1258 spec->vmaster_nid = 0x05;
1260 codec->patch_ops = ad198x_patch_ops;
1267 * AD1981 HD specific
1270 #define AD1981_SPDIF_OUT 0x02
1271 #define AD1981_DAC 0x03
1272 #define AD1981_ADC 0x04
1274 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1275 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1276 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1278 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1279 static struct hda_input_mux ad1981_capture_source = {
1282 { "Front Mic", 0x0 },
1285 { "Mix Mono", 0x3 },
1292 static struct snd_kcontrol_new ad1981_mixers[] = {
1293 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1294 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1295 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1296 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1297 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1298 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1299 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1300 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1301 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1302 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1303 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1304 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1305 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1306 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1307 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1308 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1309 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1310 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1311 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1312 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT),
1313 HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1314 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
1315 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1316 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1318 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1319 .name = "Capture Source",
1320 .info = ad198x_mux_enum_info,
1321 .get = ad198x_mux_enum_get,
1322 .put = ad198x_mux_enum_put,
1324 /* identical with AD1983 */
1326 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1327 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1328 .info = ad1983_spdif_route_info,
1329 .get = ad1983_spdif_route_get,
1330 .put = ad1983_spdif_route_put,
1335 static struct hda_verb ad1981_init_verbs[] = {
1336 /* Front, HP, Mono; mute as default */
1337 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1338 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1339 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1340 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1341 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1342 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1343 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1344 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1345 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1346 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1347 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1348 /* Front, HP selectors; from Mix */
1349 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1350 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1351 /* Mono selector; from Mix */
1352 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1353 /* Mic Mixer; select Front Mic */
1354 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1355 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1356 /* Mic boost: 0dB */
1357 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1358 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1359 /* Record selector: Front mic */
1360 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1361 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1362 /* SPDIF route: PCM */
1363 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1365 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1367 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1369 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1370 /* Front & Rear Mic Pins */
1371 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1372 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1374 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1376 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1377 /* Line-Out as Input: disabled */
1378 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1382 #ifdef CONFIG_SND_HDA_POWER_SAVE
1383 static struct hda_amp_list ad1981_loopbacks[] = {
1384 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1385 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1386 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1387 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1388 { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1394 * Patch for HP nx6320
1396 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1397 * speaker output enabled _and_ mute-LED off.
1400 #define AD1981_HP_EVENT 0x37
1401 #define AD1981_MIC_EVENT 0x38
1403 static struct hda_verb ad1981_hp_init_verbs[] = {
1404 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1405 /* pin sensing on HP and Mic jacks */
1406 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1407 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1411 /* turn on/off EAPD (+ mute HP) as a master switch */
1412 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1413 struct snd_ctl_elem_value *ucontrol)
1415 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1416 struct ad198x_spec *spec = codec->spec;
1418 if (! ad198x_eapd_put(kcontrol, ucontrol))
1420 /* change speaker pin appropriately */
1421 snd_hda_codec_write(codec, 0x05, 0,
1422 AC_VERB_SET_PIN_WIDGET_CONTROL,
1423 spec->cur_eapd ? PIN_OUT : 0);
1424 /* toggle HP mute appropriately */
1425 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1427 spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1431 /* bind volumes of both NID 0x05 and 0x06 */
1432 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1433 .ops = &snd_hda_bind_vol,
1435 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1436 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1441 /* mute internal speaker if HP is plugged */
1442 static void ad1981_hp_automute(struct hda_codec *codec)
1444 unsigned int present;
1446 present = snd_hda_codec_read(codec, 0x06, 0,
1447 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1448 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1449 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1452 /* toggle input of built-in and mic jack appropriately */
1453 static void ad1981_hp_automic(struct hda_codec *codec)
1455 static struct hda_verb mic_jack_on[] = {
1456 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1457 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1460 static struct hda_verb mic_jack_off[] = {
1461 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1462 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1465 unsigned int present;
1467 present = snd_hda_codec_read(codec, 0x08, 0,
1468 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1470 snd_hda_sequence_write(codec, mic_jack_on);
1472 snd_hda_sequence_write(codec, mic_jack_off);
1475 /* unsolicited event for HP jack sensing */
1476 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1481 case AD1981_HP_EVENT:
1482 ad1981_hp_automute(codec);
1484 case AD1981_MIC_EVENT:
1485 ad1981_hp_automic(codec);
1490 static struct hda_input_mux ad1981_hp_capture_source = {
1494 { "Docking-Station", 0x1 },
1499 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1500 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1502 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1503 .name = "Master Playback Switch",
1504 .info = ad198x_eapd_info,
1505 .get = ad198x_eapd_get,
1506 .put = ad1981_hp_master_sw_put,
1507 .private_value = 0x05,
1509 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1510 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1512 /* FIXME: analog mic/line loopback doesn't work with my tests...
1513 * (although recording is OK)
1515 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1516 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1517 HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1518 HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1519 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1520 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1521 /* FIXME: does this laptop have analog CD connection? */
1522 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1523 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1525 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1526 HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1527 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1528 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1530 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1531 .name = "Capture Source",
1532 .info = ad198x_mux_enum_info,
1533 .get = ad198x_mux_enum_get,
1534 .put = ad198x_mux_enum_put,
1539 /* initialize jack-sensing, too */
1540 static int ad1981_hp_init(struct hda_codec *codec)
1543 ad1981_hp_automute(codec);
1544 ad1981_hp_automic(codec);
1548 /* configuration for Toshiba Laptops */
1549 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1550 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1551 /* pin sensing on HP and Mic jacks */
1552 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1553 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1557 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1558 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1559 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1563 /* configuration for Lenovo Thinkpad T60 */
1564 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1565 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1566 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1567 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1568 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1569 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1570 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1571 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1572 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1573 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1574 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1575 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1577 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1578 .name = "Capture Source",
1579 .info = ad198x_mux_enum_info,
1580 .get = ad198x_mux_enum_get,
1581 .put = ad198x_mux_enum_put,
1583 /* identical with AD1983 */
1585 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1586 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1587 .info = ad1983_spdif_route_info,
1588 .get = ad1983_spdif_route_get,
1589 .put = ad1983_spdif_route_put,
1594 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1612 static const char *ad1981_models[AD1981_MODELS] = {
1614 [AD1981_THINKPAD] = "thinkpad",
1615 [AD1981_BASIC] = "basic",
1616 [AD1981_TOSHIBA] = "toshiba"
1619 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1620 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1622 SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
1623 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1624 /* Lenovo Thinkpad T60/X60/Z6xx */
1625 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
1626 /* HP nx6320 (reversed SSID, H/W bug) */
1627 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1631 static int patch_ad1981(struct hda_codec *codec)
1633 struct ad198x_spec *spec;
1636 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1642 spec->multiout.max_channels = 2;
1643 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1644 spec->multiout.dac_nids = ad1981_dac_nids;
1645 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1646 spec->num_adc_nids = 1;
1647 spec->adc_nids = ad1981_adc_nids;
1648 spec->capsrc_nids = ad1981_capsrc_nids;
1649 spec->input_mux = &ad1981_capture_source;
1650 spec->num_mixers = 1;
1651 spec->mixers[0] = ad1981_mixers;
1652 spec->num_init_verbs = 1;
1653 spec->init_verbs[0] = ad1981_init_verbs;
1654 spec->spdif_route = 0;
1655 #ifdef CONFIG_SND_HDA_POWER_SAVE
1656 spec->loopback.amplist = ad1981_loopbacks;
1658 spec->vmaster_nid = 0x05;
1660 codec->patch_ops = ad198x_patch_ops;
1662 /* override some parameters */
1663 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1666 switch (board_config) {
1668 spec->mixers[0] = ad1981_hp_mixers;
1669 spec->num_init_verbs = 2;
1670 spec->init_verbs[1] = ad1981_hp_init_verbs;
1671 spec->multiout.dig_out_nid = 0;
1672 spec->input_mux = &ad1981_hp_capture_source;
1674 codec->patch_ops.init = ad1981_hp_init;
1675 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1677 case AD1981_THINKPAD:
1678 spec->mixers[0] = ad1981_thinkpad_mixers;
1679 spec->input_mux = &ad1981_thinkpad_capture_source;
1681 case AD1981_TOSHIBA:
1682 spec->mixers[0] = ad1981_hp_mixers;
1683 spec->mixers[1] = ad1981_toshiba_mixers;
1684 spec->num_init_verbs = 2;
1685 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1686 spec->multiout.dig_out_nid = 0;
1687 spec->input_mux = &ad1981_hp_capture_source;
1688 codec->patch_ops.init = ad1981_hp_init;
1689 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1699 * Output pins and routes
1701 * Pin Mix Sel DAC (*)
1702 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1703 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1704 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
1705 * port-D 0x12 (mute/hp) <- 0x29 <- 04
1706 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1707 * port-F 0x16 (mute) <- 0x2a <- 06
1708 * port-G 0x24 (mute) <- 0x27 <- 05
1709 * port-H 0x25 (mute) <- 0x28 <- 0a
1710 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1712 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1713 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1715 * Input pins and routes
1717 * pin boost mix input # / adc input #
1718 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1719 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1720 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1721 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1722 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1723 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1724 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1725 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1729 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1730 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1732 * Inputs of Analog Mix (0x20)
1733 * 0:Port-B (front mic)
1734 * 1:Port-C/G/H (line-in)
1736 * 3:Port-D (line-in/2)
1737 * 4:Port-E/G/H (mic-in)
1738 * 5:Port-F (mic2-in)
1744 * 1:Port-B (front mic-in)
1745 * 2:Port-C (line-in)
1746 * 3:Port-F (mic2-in)
1751 * 8:Port-D (line-in/2)
1754 * Proposed pin assignments by the datasheet
1757 * Port-A front headphone
1767 * Port-A front headphone
1769 * C rear line-in/surround
1771 * E rear mic-in/CLFE
1777 * D internal speaker (with EAPD)
1778 * E/F quad mic array
1794 /* reivision id to check workarounds */
1795 #define AD1988A_REV2 0x100200
1797 #define is_rev2(codec) \
1798 ((codec)->vendor_id == 0x11d41988 && \
1799 (codec)->revision_id == AD1988A_REV2)
1805 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1806 0x04, 0x06, 0x05, 0x0a
1809 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1813 /* for AD1988A revision-2, DAC2-4 are swapped */
1814 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1815 0x04, 0x05, 0x0a, 0x06
1818 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1822 static hda_nid_t ad1988_adc_nids[3] = {
1826 static hda_nid_t ad1988_capsrc_nids[3] = {
1830 #define AD1988_SPDIF_OUT 0x02
1831 #define AD1988_SPDIF_IN 0x07
1833 static struct hda_input_mux ad1988_6stack_capture_source = {
1836 { "Front Mic", 0x1 }, /* port-B */
1837 { "Line", 0x2 }, /* port-C */
1838 { "Mic", 0x4 }, /* port-E */
1844 static struct hda_input_mux ad1988_laptop_capture_source = {
1847 { "Mic/Line", 0x1 }, /* port-B */
1855 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1856 struct snd_ctl_elem_info *uinfo)
1858 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1859 struct ad198x_spec *spec = codec->spec;
1860 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1861 spec->num_channel_mode);
1864 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
1865 struct snd_ctl_elem_value *ucontrol)
1867 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1868 struct ad198x_spec *spec = codec->spec;
1869 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
1870 spec->num_channel_mode, spec->multiout.max_channels);
1873 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
1874 struct snd_ctl_elem_value *ucontrol)
1876 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1877 struct ad198x_spec *spec = codec->spec;
1878 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
1879 spec->num_channel_mode,
1880 &spec->multiout.max_channels);
1881 if (err >= 0 && spec->need_dac_fix)
1882 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1887 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
1888 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1889 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1890 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1891 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1892 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1896 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
1897 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1898 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1899 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
1900 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
1901 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1905 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
1906 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1907 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
1908 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
1909 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
1910 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
1911 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1912 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1914 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1915 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1916 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1917 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1918 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1919 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1920 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1921 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1923 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1924 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1926 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1927 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1929 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1930 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1936 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
1937 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1938 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1939 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1940 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1944 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
1945 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1946 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1947 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
1948 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
1952 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
1953 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1954 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
1955 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
1956 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
1957 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1958 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1960 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1961 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1962 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1963 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1964 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1965 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1966 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1967 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1969 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1970 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1972 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1973 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1975 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1976 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1978 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1979 .name = "Channel Mode",
1980 .info = ad198x_ch_mode_info,
1981 .get = ad198x_ch_mode_get,
1982 .put = ad198x_ch_mode_put,
1989 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
1990 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1991 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
1992 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1994 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1995 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1996 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1997 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1998 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1999 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2001 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
2002 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2004 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2005 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2007 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2010 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2011 .name = "External Amplifier",
2012 .info = ad198x_eapd_info,
2013 .get = ad198x_eapd_get,
2014 .put = ad198x_eapd_put,
2015 .private_value = 0x12 | (1 << 8), /* port-D, inversed */
2022 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2023 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2024 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2025 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2026 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2027 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2028 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2030 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2031 /* The multiple "Capture Source" controls confuse alsamixer
2032 * So call somewhat different..
2034 /* .name = "Capture Source", */
2035 .name = "Input Source",
2037 .info = ad198x_mux_enum_info,
2038 .get = ad198x_mux_enum_get,
2039 .put = ad198x_mux_enum_put,
2044 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2045 struct snd_ctl_elem_info *uinfo)
2047 static char *texts[] = {
2048 "PCM", "ADC1", "ADC2", "ADC3"
2050 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2052 uinfo->value.enumerated.items = 4;
2053 if (uinfo->value.enumerated.item >= 4)
2054 uinfo->value.enumerated.item = 3;
2055 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2059 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2060 struct snd_ctl_elem_value *ucontrol)
2062 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2065 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2068 ucontrol->value.enumerated.item[0] = 0;
2070 sel = snd_hda_codec_read(codec, 0x0b, 0,
2071 AC_VERB_GET_CONNECT_SEL, 0);
2076 ucontrol->value.enumerated.item[0] = sel;
2081 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2082 struct snd_ctl_elem_value *ucontrol)
2084 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2085 unsigned int val, sel;
2088 val = ucontrol->value.enumerated.item[0];
2092 sel = snd_hda_codec_read(codec, 0x1d, 0,
2093 AC_VERB_GET_AMP_GAIN_MUTE,
2095 change = sel & 0x80;
2097 snd_hda_codec_write_cache(codec, 0x1d, 0,
2098 AC_VERB_SET_AMP_GAIN_MUTE,
2100 snd_hda_codec_write_cache(codec, 0x1d, 0,
2101 AC_VERB_SET_AMP_GAIN_MUTE,
2105 sel = snd_hda_codec_read(codec, 0x1d, 0,
2106 AC_VERB_GET_AMP_GAIN_MUTE,
2107 AC_AMP_GET_INPUT | 0x01);
2108 change = sel & 0x80;
2110 snd_hda_codec_write_cache(codec, 0x1d, 0,
2111 AC_VERB_SET_AMP_GAIN_MUTE,
2113 snd_hda_codec_write_cache(codec, 0x1d, 0,
2114 AC_VERB_SET_AMP_GAIN_MUTE,
2117 sel = snd_hda_codec_read(codec, 0x0b, 0,
2118 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2119 change |= sel != val;
2121 snd_hda_codec_write_cache(codec, 0x0b, 0,
2122 AC_VERB_SET_CONNECT_SEL,
2128 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2129 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2131 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2132 .name = "IEC958 Playback Source",
2133 .info = ad1988_spdif_playback_source_info,
2134 .get = ad1988_spdif_playback_source_get,
2135 .put = ad1988_spdif_playback_source_put,
2140 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2141 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2147 * initialization verbs
2151 * for 6-stack (+dig)
2153 static struct hda_verb ad1988_6stack_init_verbs[] = {
2154 /* Front, Surround, CLFE, side DAC; unmute as default */
2155 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2156 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2157 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2158 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2159 /* Port-A front headphon path */
2160 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2161 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2162 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2163 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2164 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2165 /* Port-D line-out path */
2166 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2167 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2168 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2169 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2170 /* Port-F surround path */
2171 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2172 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2173 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2174 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2175 /* Port-G CLFE path */
2176 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2177 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2178 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2179 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2180 /* Port-H side path */
2181 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2182 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2183 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2184 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2186 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2187 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2188 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2189 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2190 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2191 /* Port-B front mic-in path */
2192 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2193 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2194 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2195 /* Port-C line-in path */
2196 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2197 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2198 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2199 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2200 /* Port-E mic-in path */
2201 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2202 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2203 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2204 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2205 /* Analog CD Input */
2206 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2211 static struct hda_verb ad1988_capture_init_verbs[] = {
2212 /* mute analog mix */
2213 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2214 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2215 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2216 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2217 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2218 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2219 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2220 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2221 /* select ADCs - front-mic */
2222 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2223 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2224 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2226 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2227 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2228 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2233 static struct hda_verb ad1988_spdif_init_verbs[] = {
2235 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2236 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2237 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2238 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2240 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2246 * verbs for 3stack (+dig)
2248 static struct hda_verb ad1988_3stack_ch2_init[] = {
2249 /* set port-C to line-in */
2250 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2251 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2252 /* set port-E to mic-in */
2253 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2254 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2258 static struct hda_verb ad1988_3stack_ch6_init[] = {
2259 /* set port-C to surround out */
2260 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2261 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2262 /* set port-E to CLFE out */
2263 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2264 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2268 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2269 { 2, ad1988_3stack_ch2_init },
2270 { 6, ad1988_3stack_ch6_init },
2273 static struct hda_verb ad1988_3stack_init_verbs[] = {
2274 /* Front, Surround, CLFE, side DAC; unmute as default */
2275 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2276 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2277 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2278 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2279 /* Port-A front headphon path */
2280 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2281 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2282 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2283 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2284 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2285 /* Port-D line-out path */
2286 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2287 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2288 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2289 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2291 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2292 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2293 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2294 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2295 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2296 /* Port-B front mic-in path */
2297 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2298 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2299 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2300 /* Port-C line-in/surround path - 6ch mode as default */
2301 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2302 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2303 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2304 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2305 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2306 /* Port-E mic-in/CLFE path - 6ch mode as default */
2307 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2308 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2309 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2310 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2311 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2312 /* mute analog mix */
2313 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2314 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2315 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2316 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2317 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2318 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2319 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2320 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2321 /* select ADCs - front-mic */
2322 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2323 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2324 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2326 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2327 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2328 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2333 * verbs for laptop mode (+dig)
2335 static struct hda_verb ad1988_laptop_hp_on[] = {
2336 /* unmute port-A and mute port-D */
2337 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2338 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2341 static struct hda_verb ad1988_laptop_hp_off[] = {
2342 /* mute port-A and unmute port-D */
2343 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2344 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2348 #define AD1988_HP_EVENT 0x01
2350 static struct hda_verb ad1988_laptop_init_verbs[] = {
2351 /* Front, Surround, CLFE, side DAC; unmute as default */
2352 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2353 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2354 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2355 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2356 /* Port-A front headphon path */
2357 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2358 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2359 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2360 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2361 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2362 /* unsolicited event for pin-sense */
2363 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2364 /* Port-D line-out path + EAPD */
2365 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2366 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2367 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2368 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2369 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2371 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2372 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2373 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2374 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2375 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2376 /* Port-B mic-in path */
2377 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2378 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2379 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2380 /* Port-C docking station - try to output */
2381 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2382 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2383 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2384 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2385 /* mute analog mix */
2386 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2387 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2388 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2389 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2390 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2391 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2392 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2393 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2394 /* select ADCs - mic */
2395 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2396 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2397 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2399 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2400 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2401 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2405 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2407 if ((res >> 26) != AD1988_HP_EVENT)
2409 if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
2410 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2412 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2415 #ifdef CONFIG_SND_HDA_POWER_SAVE
2416 static struct hda_amp_list ad1988_loopbacks[] = {
2417 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2418 { 0x20, HDA_INPUT, 1 }, /* Line */
2419 { 0x20, HDA_INPUT, 4 }, /* Mic */
2420 { 0x20, HDA_INPUT, 6 }, /* CD */
2426 * Automatic parse of I/O pins from the BIOS configuration
2429 #define NUM_CONTROL_ALLOC 32
2430 #define NUM_VERB_ALLOC 32
2437 static struct snd_kcontrol_new ad1988_control_templates[] = {
2438 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2439 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2440 HDA_BIND_MUTE(NULL, 0, 0, 0),
2443 /* add dynamic controls */
2444 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2447 struct snd_kcontrol_new *knew;
2449 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2450 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2452 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2455 if (spec->kctl_alloc) {
2456 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2457 kfree(spec->kctl_alloc);
2459 spec->kctl_alloc = knew;
2460 spec->num_kctl_alloc = num;
2463 knew = &spec->kctl_alloc[spec->num_kctl_used];
2464 *knew = ad1988_control_templates[type];
2465 knew->name = kstrdup(name, GFP_KERNEL);
2468 knew->private_value = val;
2469 spec->num_kctl_used++;
2473 #define AD1988_PIN_CD_NID 0x18
2474 #define AD1988_PIN_BEEP_NID 0x10
2476 static hda_nid_t ad1988_mixer_nids[8] = {
2477 /* A B C D E F G H */
2478 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2481 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2483 static hda_nid_t idx_to_dac[8] = {
2484 /* A B C D E F G H */
2485 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2487 static hda_nid_t idx_to_dac_rev2[8] = {
2488 /* A B C D E F G H */
2489 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2492 return idx_to_dac_rev2[idx];
2494 return idx_to_dac[idx];
2497 static hda_nid_t ad1988_boost_nids[8] = {
2498 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2501 static int ad1988_pin_idx(hda_nid_t nid)
2503 static hda_nid_t ad1988_io_pins[8] = {
2504 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2507 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2508 if (ad1988_io_pins[i] == nid)
2510 return 0; /* should be -1 */
2513 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2515 static int loopback_idx[8] = {
2516 2, 0, 1, 3, 4, 5, 1, 4
2519 case AD1988_PIN_CD_NID:
2522 return loopback_idx[ad1988_pin_idx(nid)];
2526 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2528 static int adc_idx[8] = {
2529 0, 1, 2, 8, 4, 3, 6, 7
2532 case AD1988_PIN_CD_NID:
2535 return adc_idx[ad1988_pin_idx(nid)];
2539 /* fill in the dac_nids table from the parsed pin configuration */
2540 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2541 const struct auto_pin_cfg *cfg)
2543 struct ad198x_spec *spec = codec->spec;
2546 spec->multiout.dac_nids = spec->private_dac_nids;
2548 /* check the pins hardwired to audio widget */
2549 for (i = 0; i < cfg->line_outs; i++) {
2550 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2551 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2553 spec->multiout.num_dacs = cfg->line_outs;
2557 /* add playback controls from the parsed DAC table */
2558 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2559 const struct auto_pin_cfg *cfg)
2562 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2566 for (i = 0; i < cfg->line_outs; i++) {
2567 hda_nid_t dac = spec->multiout.dac_nids[i];
2570 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2573 err = add_control(spec, AD_CTL_WIDGET_VOL,
2574 "Center Playback Volume",
2575 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2578 err = add_control(spec, AD_CTL_WIDGET_VOL,
2579 "LFE Playback Volume",
2580 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2583 err = add_control(spec, AD_CTL_BIND_MUTE,
2584 "Center Playback Switch",
2585 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2588 err = add_control(spec, AD_CTL_BIND_MUTE,
2589 "LFE Playback Switch",
2590 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2594 sprintf(name, "%s Playback Volume", chname[i]);
2595 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2596 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2599 sprintf(name, "%s Playback Switch", chname[i]);
2600 err = add_control(spec, AD_CTL_BIND_MUTE, name,
2601 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2609 /* add playback controls for speaker and HP outputs */
2610 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2613 struct ad198x_spec *spec = codec->spec;
2621 idx = ad1988_pin_idx(pin);
2622 nid = ad1988_idx_to_dac(codec, idx);
2623 /* specify the DAC as the extra output */
2624 if (! spec->multiout.hp_nid)
2625 spec->multiout.hp_nid = nid;
2627 spec->multiout.extra_out_nid[0] = nid;
2628 /* control HP volume/switch on the output mixer amp */
2629 sprintf(name, "%s Playback Volume", pfx);
2630 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2631 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2633 nid = ad1988_mixer_nids[idx];
2634 sprintf(name, "%s Playback Switch", pfx);
2635 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2636 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2641 /* create input playback/capture controls for the given pin */
2642 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2643 const char *ctlname, int boost)
2648 sprintf(name, "%s Playback Volume", ctlname);
2649 idx = ad1988_pin_to_loopback_idx(pin);
2650 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2651 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2653 sprintf(name, "%s Playback Switch", ctlname);
2654 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2655 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2659 idx = ad1988_pin_idx(pin);
2660 bnid = ad1988_boost_nids[idx];
2662 sprintf(name, "%s Boost", ctlname);
2663 return add_control(spec, AD_CTL_WIDGET_VOL, name,
2664 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2671 /* create playback/capture controls for input pins */
2672 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2673 const struct auto_pin_cfg *cfg)
2675 struct hda_input_mux *imux = &spec->private_imux;
2678 for (i = 0; i < AUTO_PIN_LAST; i++) {
2679 err = new_analog_input(spec, cfg->input_pins[i],
2680 auto_pin_cfg_labels[i],
2681 i <= AUTO_PIN_FRONT_MIC);
2684 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2685 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2688 imux->items[imux->num_items].label = "Mix";
2689 imux->items[imux->num_items].index = 9;
2692 if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2693 "Analog Mix Playback Volume",
2694 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2696 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2697 "Analog Mix Playback Switch",
2698 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2704 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2705 hda_nid_t nid, int pin_type,
2709 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2710 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2712 case 0x11: /* port-A - DAC 04 */
2713 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2715 case 0x14: /* port-B - DAC 06 */
2716 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2718 case 0x15: /* port-C - DAC 05 */
2719 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2721 case 0x17: /* port-E - DAC 0a */
2722 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2724 case 0x13: /* mono - DAC 04 */
2725 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2730 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2732 struct ad198x_spec *spec = codec->spec;
2735 for (i = 0; i < spec->autocfg.line_outs; i++) {
2736 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2737 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2741 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2743 struct ad198x_spec *spec = codec->spec;
2746 pin = spec->autocfg.speaker_pins[0];
2747 if (pin) /* connect to front */
2748 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2749 pin = spec->autocfg.hp_pins[0];
2750 if (pin) /* connect to front */
2751 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2754 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2756 struct ad198x_spec *spec = codec->spec;
2759 for (i = 0; i < AUTO_PIN_LAST; i++) {
2760 hda_nid_t nid = spec->autocfg.input_pins[i];
2764 case 0x15: /* port-C */
2765 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2767 case 0x17: /* port-E */
2768 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2771 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2772 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2773 if (nid != AD1988_PIN_CD_NID)
2774 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2776 idx = ad1988_pin_idx(nid);
2777 if (ad1988_boost_nids[idx])
2778 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2779 AC_VERB_SET_AMP_GAIN_MUTE,
2784 /* parse the BIOS configuration and set up the alc_spec */
2785 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2786 static int ad1988_parse_auto_config(struct hda_codec *codec)
2788 struct ad198x_spec *spec = codec->spec;
2791 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2793 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2795 if (! spec->autocfg.line_outs)
2796 return 0; /* can't find valid BIOS pin config */
2797 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2798 (err = ad1988_auto_create_extra_out(codec,
2799 spec->autocfg.speaker_pins[0],
2801 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2802 "Headphone")) < 0 ||
2803 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2806 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2808 if (spec->autocfg.dig_out_pin)
2809 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2810 if (spec->autocfg.dig_in_pin)
2811 spec->dig_in_nid = AD1988_SPDIF_IN;
2813 if (spec->kctl_alloc)
2814 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2816 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2818 spec->input_mux = &spec->private_imux;
2823 /* init callback for auto-configuration model -- overriding the default init */
2824 static int ad1988_auto_init(struct hda_codec *codec)
2827 ad1988_auto_init_multi_out(codec);
2828 ad1988_auto_init_extra_out(codec);
2829 ad1988_auto_init_analog_input(codec);
2837 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2838 [AD1988_6STACK] = "6stack",
2839 [AD1988_6STACK_DIG] = "6stack-dig",
2840 [AD1988_3STACK] = "3stack",
2841 [AD1988_3STACK_DIG] = "3stack-dig",
2842 [AD1988_LAPTOP] = "laptop",
2843 [AD1988_LAPTOP_DIG] = "laptop-dig",
2844 [AD1988_AUTO] = "auto",
2847 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2848 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2849 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2853 static int patch_ad1988(struct hda_codec *codec)
2855 struct ad198x_spec *spec;
2858 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2865 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
2867 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
2868 ad1988_models, ad1988_cfg_tbl);
2869 if (board_config < 0) {
2870 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
2871 board_config = AD1988_AUTO;
2874 if (board_config == AD1988_AUTO) {
2875 /* automatic parse from the BIOS config */
2876 int err = ad1988_parse_auto_config(codec);
2881 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n");
2882 board_config = AD1988_6STACK;
2886 switch (board_config) {
2888 case AD1988_6STACK_DIG:
2889 spec->multiout.max_channels = 8;
2890 spec->multiout.num_dacs = 4;
2892 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
2894 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
2895 spec->input_mux = &ad1988_6stack_capture_source;
2896 spec->num_mixers = 2;
2898 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
2900 spec->mixers[0] = ad1988_6stack_mixers1;
2901 spec->mixers[1] = ad1988_6stack_mixers2;
2902 spec->num_init_verbs = 1;
2903 spec->init_verbs[0] = ad1988_6stack_init_verbs;
2904 if (board_config == AD1988_6STACK_DIG) {
2905 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2906 spec->dig_in_nid = AD1988_SPDIF_IN;
2910 case AD1988_3STACK_DIG:
2911 spec->multiout.max_channels = 6;
2912 spec->multiout.num_dacs = 3;
2914 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
2916 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2917 spec->input_mux = &ad1988_6stack_capture_source;
2918 spec->channel_mode = ad1988_3stack_modes;
2919 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
2920 spec->num_mixers = 2;
2922 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
2924 spec->mixers[0] = ad1988_3stack_mixers1;
2925 spec->mixers[1] = ad1988_3stack_mixers2;
2926 spec->num_init_verbs = 1;
2927 spec->init_verbs[0] = ad1988_3stack_init_verbs;
2928 if (board_config == AD1988_3STACK_DIG)
2929 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2932 case AD1988_LAPTOP_DIG:
2933 spec->multiout.max_channels = 2;
2934 spec->multiout.num_dacs = 1;
2935 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2936 spec->input_mux = &ad1988_laptop_capture_source;
2937 spec->num_mixers = 1;
2938 spec->mixers[0] = ad1988_laptop_mixers;
2939 spec->num_init_verbs = 1;
2940 spec->init_verbs[0] = ad1988_laptop_init_verbs;
2941 if (board_config == AD1988_LAPTOP_DIG)
2942 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2946 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
2947 spec->adc_nids = ad1988_adc_nids;
2948 spec->capsrc_nids = ad1988_capsrc_nids;
2949 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
2950 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
2951 if (spec->multiout.dig_out_nid) {
2952 spec->mixers[spec->num_mixers++] = ad1988_spdif_out_mixers;
2953 spec->init_verbs[spec->num_init_verbs++] = ad1988_spdif_init_verbs;
2955 if (spec->dig_in_nid)
2956 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
2958 codec->patch_ops = ad198x_patch_ops;
2959 switch (board_config) {
2961 codec->patch_ops.init = ad1988_auto_init;
2964 case AD1988_LAPTOP_DIG:
2965 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
2968 #ifdef CONFIG_SND_HDA_POWER_SAVE
2969 spec->loopback.amplist = ad1988_loopbacks;
2971 spec->vmaster_nid = 0x04;
2980 * port-B - front line/mic-in
2981 * port-E - aux in/out
2982 * port-F - aux in/out
2983 * port-C - rear line/mic-in
2984 * port-D - rear line/hp-out
2985 * port-A - front line/hp-out
2987 * AD1984 = AD1884 + two digital mic-ins
2990 * For simplicity, we share the single DAC for both HP and line-outs
2991 * right now. The inidividual playbacks could be easily implemented,
2992 * but no build-up framework is given, so far.
2995 static hda_nid_t ad1884_dac_nids[1] = {
2999 static hda_nid_t ad1884_adc_nids[2] = {
3003 static hda_nid_t ad1884_capsrc_nids[2] = {
3007 #define AD1884_SPDIF_OUT 0x02
3009 static struct hda_input_mux ad1884_capture_source = {
3012 { "Front Mic", 0x0 },
3019 static struct snd_kcontrol_new ad1884_base_mixers[] = {
3020 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3021 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3022 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3023 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3024 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3025 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3026 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3027 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3028 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3029 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3030 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3031 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3033 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3034 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3035 HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
3036 HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
3038 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3039 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3040 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3041 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3042 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3043 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3045 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3046 /* The multiple "Capture Source" controls confuse alsamixer
3047 * So call somewhat different..
3049 /* .name = "Capture Source", */
3050 .name = "Input Source",
3052 .info = ad198x_mux_enum_info,
3053 .get = ad198x_mux_enum_get,
3054 .put = ad198x_mux_enum_put,
3056 /* SPDIF controls */
3057 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3059 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3060 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3061 /* identical with ad1983 */
3062 .info = ad1983_spdif_route_info,
3063 .get = ad1983_spdif_route_get,
3064 .put = ad1983_spdif_route_put,
3069 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3070 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3071 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3072 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3074 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3080 * initialization verbs
3082 static struct hda_verb ad1884_init_verbs[] = {
3083 /* DACs; mute as default */
3084 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3085 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3086 /* Port-A (HP) mixer */
3087 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3088 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3090 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3091 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3092 /* HP selector - select DAC2 */
3093 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3094 /* Port-D (Line-out) mixer */
3095 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3096 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3098 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3099 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3100 /* Mono-out mixer */
3101 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3102 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3104 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3105 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3107 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3108 /* Port-B (front mic) pin */
3109 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3110 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3111 /* Port-C (rear mic) pin */
3112 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3113 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3114 /* Analog mixer; mute as default */
3115 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3116 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3117 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3118 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3119 /* Analog Mix output amp */
3120 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3121 /* SPDIF output selector */
3122 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3123 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3127 #ifdef CONFIG_SND_HDA_POWER_SAVE
3128 static struct hda_amp_list ad1884_loopbacks[] = {
3129 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3130 { 0x20, HDA_INPUT, 1 }, /* Mic */
3131 { 0x20, HDA_INPUT, 2 }, /* CD */
3132 { 0x20, HDA_INPUT, 4 }, /* Docking */
3137 static const char *ad1884_slave_vols[] = {
3138 "PCM Playback Volume",
3139 "Mic Playback Volume",
3140 "Mono Playback Volume",
3141 "Front Mic Playback Volume",
3142 "Mic Playback Volume",
3143 "CD Playback Volume",
3144 "Internal Mic Playback Volume",
3145 "Docking Mic Playback Volume"
3146 "Beep Playback Volume",
3147 "IEC958 Playback Volume",
3151 static int patch_ad1884(struct hda_codec *codec)
3153 struct ad198x_spec *spec;
3155 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3159 mutex_init(&spec->amp_mutex);
3162 spec->multiout.max_channels = 2;
3163 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3164 spec->multiout.dac_nids = ad1884_dac_nids;
3165 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3166 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3167 spec->adc_nids = ad1884_adc_nids;
3168 spec->capsrc_nids = ad1884_capsrc_nids;
3169 spec->input_mux = &ad1884_capture_source;
3170 spec->num_mixers = 1;
3171 spec->mixers[0] = ad1884_base_mixers;
3172 spec->num_init_verbs = 1;
3173 spec->init_verbs[0] = ad1884_init_verbs;
3174 spec->spdif_route = 0;
3175 #ifdef CONFIG_SND_HDA_POWER_SAVE
3176 spec->loopback.amplist = ad1884_loopbacks;
3178 spec->vmaster_nid = 0x04;
3179 /* we need to cover all playback volumes */
3180 spec->slave_vols = ad1884_slave_vols;
3182 codec->patch_ops = ad198x_patch_ops;
3188 * Lenovo Thinkpad T61/X61
3190 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3194 { "Internal Mic", 0x1 },
3201 * Dell Precision T3400
3203 static struct hda_input_mux ad1984_dell_desktop_capture_source = {
3206 { "Front Mic", 0x0 },
3213 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3214 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3215 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3216 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3217 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3218 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3219 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3220 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3221 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3222 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3223 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3224 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3225 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3226 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3227 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3228 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3229 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3230 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3231 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3232 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3234 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3235 /* The multiple "Capture Source" controls confuse alsamixer
3236 * So call somewhat different..
3238 /* .name = "Capture Source", */
3239 .name = "Input Source",
3241 .info = ad198x_mux_enum_info,
3242 .get = ad198x_mux_enum_get,
3243 .put = ad198x_mux_enum_put,
3245 /* SPDIF controls */
3246 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3248 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3249 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3250 /* identical with ad1983 */
3251 .info = ad1983_spdif_route_info,
3252 .get = ad1983_spdif_route_get,
3253 .put = ad1983_spdif_route_put,
3258 /* additional verbs */
3259 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3260 /* Port-E (docking station mic) pin */
3261 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3262 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3263 /* docking mic boost */
3264 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3265 /* Analog mixer - docking mic; mute as default */
3266 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3267 /* enable EAPD bit */
3268 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3273 * Dell Precision T3400
3275 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3276 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3277 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3278 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3279 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3280 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3281 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3282 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3283 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3284 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3286 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3287 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3289 HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3290 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3291 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3292 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3293 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3294 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3296 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3297 /* The multiple "Capture Source" controls confuse alsamixer
3298 * So call somewhat different..
3300 /* .name = "Capture Source", */
3301 .name = "Input Source",
3303 .info = ad198x_mux_enum_info,
3304 .get = ad198x_mux_enum_get,
3305 .put = ad198x_mux_enum_put,
3310 /* Digial MIC ADC NID 0x05 + 0x06 */
3311 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3312 struct hda_codec *codec,
3313 unsigned int stream_tag,
3314 unsigned int format,
3315 struct snd_pcm_substream *substream)
3317 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3318 stream_tag, 0, format);
3322 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3323 struct hda_codec *codec,
3324 struct snd_pcm_substream *substream)
3326 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3331 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3337 .prepare = ad1984_pcm_dmic_prepare,
3338 .cleanup = ad1984_pcm_dmic_cleanup
3342 static int ad1984_build_pcms(struct hda_codec *codec)
3344 struct ad198x_spec *spec = codec->spec;
3345 struct hda_pcm *info;
3348 err = ad198x_build_pcms(codec);
3352 info = spec->pcm_rec + codec->num_pcms;
3354 info->name = "AD1984 Digital Mic";
3355 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3363 AD1984_DELL_DESKTOP,
3367 static const char *ad1984_models[AD1984_MODELS] = {
3368 [AD1984_BASIC] = "basic",
3369 [AD1984_THINKPAD] = "thinkpad",
3370 [AD1984_DELL_DESKTOP] = "dell_desktop",
3373 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3374 /* Lenovo Thinkpad T61/X61 */
3375 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1984_THINKPAD),
3376 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3380 static int patch_ad1984(struct hda_codec *codec)
3382 struct ad198x_spec *spec;
3383 int board_config, err;
3385 err = patch_ad1884(codec);
3389 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3390 ad1984_models, ad1984_cfg_tbl);
3391 switch (board_config) {
3393 /* additional digital mics */
3394 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3395 codec->patch_ops.build_pcms = ad1984_build_pcms;
3397 case AD1984_THINKPAD:
3398 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3399 spec->input_mux = &ad1984_thinkpad_capture_source;
3400 spec->mixers[0] = ad1984_thinkpad_mixers;
3401 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3403 case AD1984_DELL_DESKTOP:
3404 spec->multiout.dig_out_nid = 0;
3405 spec->input_mux = &ad1984_dell_desktop_capture_source;
3406 spec->mixers[0] = ad1984_dell_desktop_mixers;
3414 * AD1883 / AD1884A / AD1984A / AD1984B
3416 * port-B (0x14) - front mic-in
3417 * port-E (0x1c) - rear mic-in
3418 * port-F (0x16) - CD / ext out
3419 * port-C (0x15) - rear line-in
3420 * port-D (0x12) - rear line-out
3421 * port-A (0x11) - front hp-out
3423 * AD1984A = AD1884A + digital-mic
3424 * AD1883 = equivalent with AD1984A
3425 * AD1984B = AD1984A + extra SPDIF-out
3428 * We share the single DAC for both HP and line-outs (see AD1884/1984).
3431 static hda_nid_t ad1884a_dac_nids[1] = {
3435 #define ad1884a_adc_nids ad1884_adc_nids
3436 #define ad1884a_capsrc_nids ad1884_capsrc_nids
3438 #define AD1884A_SPDIF_OUT 0x02
3440 static struct hda_input_mux ad1884a_capture_source = {
3443 { "Front Mic", 0x0 },
3451 static struct snd_kcontrol_new ad1884a_base_mixers[] = {
3452 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3453 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3454 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3455 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3456 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3457 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3458 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3459 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3460 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3461 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3462 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
3463 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
3464 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3465 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3466 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3467 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3468 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3469 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3470 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3471 HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
3472 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3473 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3474 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3475 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3476 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3478 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3479 /* The multiple "Capture Source" controls confuse alsamixer
3480 * So call somewhat different..
3482 /* .name = "Capture Source", */
3483 .name = "Input Source",
3485 .info = ad198x_mux_enum_info,
3486 .get = ad198x_mux_enum_get,
3487 .put = ad198x_mux_enum_put,
3489 /* SPDIF controls */
3490 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3492 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3493 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3494 /* identical with ad1983 */
3495 .info = ad1983_spdif_route_info,
3496 .get = ad1983_spdif_route_get,
3497 .put = ad1983_spdif_route_put,
3503 * initialization verbs
3505 static struct hda_verb ad1884a_init_verbs[] = {
3506 /* DACs; unmute as default */
3507 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3508 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3509 /* Port-A (HP) mixer - route only from analog mixer */
3510 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3511 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3513 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3514 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3515 /* Port-D (Line-out) mixer - route only from analog mixer */
3516 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3517 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3519 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3520 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3521 /* Mono-out mixer - route only from analog mixer */
3522 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3523 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3525 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3526 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3527 /* Port-B (front mic) pin */
3528 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3529 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3530 /* Port-C (rear line-in) pin */
3531 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3532 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3533 /* Port-E (rear mic) pin */
3534 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3535 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3536 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
3537 /* Port-F (CD) pin */
3538 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3539 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3540 /* Analog mixer; mute as default */
3541 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3542 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3543 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3544 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3545 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
3546 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3547 /* Analog Mix output amp */
3548 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3549 /* capture sources */
3550 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
3551 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3552 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3553 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3554 /* SPDIF output amp */
3555 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3559 #ifdef CONFIG_SND_HDA_POWER_SAVE
3560 static struct hda_amp_list ad1884a_loopbacks[] = {
3561 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3562 { 0x20, HDA_INPUT, 1 }, /* Mic */
3563 { 0x20, HDA_INPUT, 2 }, /* CD */
3564 { 0x20, HDA_INPUT, 4 }, /* Docking */
3572 * Port A: Headphone jack
3574 * Port C: Internal MIC
3575 * Port D: Dock Line Out (if enabled)
3576 * Port E: Dock Line In (if enabled)
3577 * Port F: Internal speakers
3580 static struct hda_input_mux ad1884a_laptop_capture_source = {
3583 { "Mic", 0x0 }, /* port-B */
3584 { "Internal Mic", 0x1 }, /* port-C */
3585 { "Dock Mic", 0x4 }, /* port-E */
3590 static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
3591 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3592 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3593 HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3594 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3595 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3596 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3597 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3598 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3599 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3600 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3601 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3602 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3603 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3604 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3605 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3606 HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3607 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3608 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3609 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3610 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3612 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3613 /* The multiple "Capture Source" controls confuse alsamixer
3614 * So call somewhat different..
3616 /* .name = "Capture Source", */
3617 .name = "Input Source",
3619 .info = ad198x_mux_enum_info,
3620 .get = ad198x_mux_enum_get,
3621 .put = ad198x_mux_enum_put,
3626 static struct hda_input_mux ad1884a_mobile_capture_source = {
3629 { "Mic", 0x1 }, /* port-C */
3634 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
3635 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3636 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3637 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3638 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3639 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3640 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3641 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3642 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3643 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3644 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3645 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3647 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3648 .name = "Capture Source",
3649 .info = ad198x_mux_enum_info,
3650 .get = ad198x_mux_enum_get,
3651 .put = ad198x_mux_enum_put,
3656 /* mute internal speaker if HP is plugged */
3657 static void ad1884a_hp_automute(struct hda_codec *codec)
3659 unsigned int present;
3661 present = snd_hda_codec_read(codec, 0x11, 0,
3662 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
3663 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3664 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3665 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3666 present ? 0x00 : 0x02);
3669 #define AD1884A_HP_EVENT 0x37
3671 /* unsolicited event for HP jack sensing */
3672 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
3674 if ((res >> 26) != AD1884A_HP_EVENT)
3676 ad1884a_hp_automute(codec);
3679 /* initialize jack-sensing, too */
3680 static int ad1884a_hp_init(struct hda_codec *codec)
3683 ad1884a_hp_automute(codec);
3687 /* additional verbs for laptop model */
3688 static struct hda_verb ad1884a_laptop_verbs[] = {
3689 /* Port-A (HP) pin - always unmuted */
3690 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3691 /* Port-F (int speaker) mixer - route only from analog mixer */
3692 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3693 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3695 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3696 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3698 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3699 /* unsolicited event for pin-sense */
3700 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3714 static const char *ad1884a_models[AD1884A_MODELS] = {
3715 [AD1884A_DESKTOP] = "desktop",
3716 [AD1884A_LAPTOP] = "laptop",
3717 [AD1884A_MOBILE] = "mobile",
3720 static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
3721 SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
3725 static int patch_ad1884a(struct hda_codec *codec)
3727 struct ad198x_spec *spec;
3730 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3734 mutex_init(&spec->amp_mutex);
3737 spec->multiout.max_channels = 2;
3738 spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
3739 spec->multiout.dac_nids = ad1884a_dac_nids;
3740 spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
3741 spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
3742 spec->adc_nids = ad1884a_adc_nids;
3743 spec->capsrc_nids = ad1884a_capsrc_nids;
3744 spec->input_mux = &ad1884a_capture_source;
3745 spec->num_mixers = 1;
3746 spec->mixers[0] = ad1884a_base_mixers;
3747 spec->num_init_verbs = 1;
3748 spec->init_verbs[0] = ad1884a_init_verbs;
3749 spec->spdif_route = 0;
3750 #ifdef CONFIG_SND_HDA_POWER_SAVE
3751 spec->loopback.amplist = ad1884a_loopbacks;
3753 codec->patch_ops = ad198x_patch_ops;
3755 /* override some parameters */
3756 board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
3759 switch (board_config) {
3760 case AD1884A_LAPTOP:
3761 spec->mixers[0] = ad1884a_laptop_mixers;
3762 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
3763 spec->multiout.dig_out_nid = 0;
3764 spec->input_mux = &ad1884a_laptop_capture_source;
3765 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
3766 codec->patch_ops.init = ad1884a_hp_init;
3768 case AD1884A_MOBILE:
3769 spec->mixers[0] = ad1884a_mobile_mixers;
3770 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
3771 spec->multiout.dig_out_nid = 0;
3772 spec->input_mux = &ad1884a_mobile_capture_source;
3773 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
3774 codec->patch_ops.init = ad1884a_hp_init;
3785 * port-A - front hp-out
3786 * port-B - front mic-in
3787 * port-C - rear line-in, shared surr-out (3stack)
3788 * port-D - rear line-out
3789 * port-E - rear mic-in, shared clfe-out (3stack)
3790 * port-F - rear surr-out (6stack)
3791 * port-G - rear clfe-out (6stack)
3794 static hda_nid_t ad1882_dac_nids[3] = {
3798 static hda_nid_t ad1882_adc_nids[2] = {
3802 static hda_nid_t ad1882_capsrc_nids[2] = {
3806 #define AD1882_SPDIF_OUT 0x02
3808 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
3809 static struct hda_input_mux ad1882_capture_source = {
3812 { "Front Mic", 0x1 },
3820 static struct snd_kcontrol_new ad1882_base_mixers[] = {
3821 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3822 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
3823 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
3824 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
3825 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3826 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3827 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3828 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3829 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3830 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3831 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3832 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3833 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
3834 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
3835 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
3836 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
3837 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
3838 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
3839 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
3840 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
3841 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
3842 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3843 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3844 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3845 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3847 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3848 /* The multiple "Capture Source" controls confuse alsamixer
3849 * So call somewhat different..
3851 /* .name = "Capture Source", */
3852 .name = "Input Source",
3854 .info = ad198x_mux_enum_info,
3855 .get = ad198x_mux_enum_get,
3856 .put = ad198x_mux_enum_put,
3858 /* SPDIF controls */
3859 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3861 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3862 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3863 /* identical with ad1983 */
3864 .info = ad1983_spdif_route_info,
3865 .get = ad1983_spdif_route_get,
3866 .put = ad1983_spdif_route_put,
3871 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
3872 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
3873 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
3874 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
3876 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3877 .name = "Channel Mode",
3878 .info = ad198x_ch_mode_info,
3879 .get = ad198x_ch_mode_get,
3880 .put = ad198x_ch_mode_put,
3885 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
3886 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
3887 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
3888 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
3892 static struct hda_verb ad1882_ch2_init[] = {
3893 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3894 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3895 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3896 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3897 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3898 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3902 static struct hda_verb ad1882_ch4_init[] = {
3903 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3904 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3905 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3906 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3907 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3908 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3912 static struct hda_verb ad1882_ch6_init[] = {
3913 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3914 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3915 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3916 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3917 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3918 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3922 static struct hda_channel_mode ad1882_modes[3] = {
3923 { 2, ad1882_ch2_init },
3924 { 4, ad1882_ch4_init },
3925 { 6, ad1882_ch6_init },
3929 * initialization verbs
3931 static struct hda_verb ad1882_init_verbs[] = {
3932 /* DACs; mute as default */
3933 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3934 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3935 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3936 /* Port-A (HP) mixer */
3937 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3938 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3940 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3941 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3942 /* HP selector - select DAC2 */
3943 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
3944 /* Port-D (Line-out) mixer */
3945 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3946 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3948 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3949 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3950 /* Mono-out mixer */
3951 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3952 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3954 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3955 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3956 /* Port-B (front mic) pin */
3957 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3958 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3959 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3960 /* Port-C (line-in) pin */
3961 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3962 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3963 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3964 /* Port-C mixer - mute as input */
3965 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3966 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3967 /* Port-E (mic-in) pin */
3968 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3969 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3970 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3971 /* Port-E mixer - mute as input */
3972 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3973 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3974 /* Port-F (surround) */
3975 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3976 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3978 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3979 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3980 /* Analog mixer; mute as default */
3981 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
3982 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3983 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3984 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3985 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3986 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3987 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3988 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3989 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3990 /* Analog Mix output amp */
3991 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3992 /* SPDIF output selector */
3993 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3994 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3995 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3999 #ifdef CONFIG_SND_HDA_POWER_SAVE
4000 static struct hda_amp_list ad1882_loopbacks[] = {
4001 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4002 { 0x20, HDA_INPUT, 1 }, /* Mic */
4003 { 0x20, HDA_INPUT, 4 }, /* Line */
4004 { 0x20, HDA_INPUT, 6 }, /* CD */
4016 static const char *ad1882_models[AD1986A_MODELS] = {
4017 [AD1882_3STACK] = "3stack",
4018 [AD1882_6STACK] = "6stack",
4022 static int patch_ad1882(struct hda_codec *codec)
4024 struct ad198x_spec *spec;
4027 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4031 mutex_init(&spec->amp_mutex);
4034 spec->multiout.max_channels = 6;
4035 spec->multiout.num_dacs = 3;
4036 spec->multiout.dac_nids = ad1882_dac_nids;
4037 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
4038 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
4039 spec->adc_nids = ad1882_adc_nids;
4040 spec->capsrc_nids = ad1882_capsrc_nids;
4041 spec->input_mux = &ad1882_capture_source;
4042 spec->num_mixers = 1;
4043 spec->mixers[0] = ad1882_base_mixers;
4044 spec->num_init_verbs = 1;
4045 spec->init_verbs[0] = ad1882_init_verbs;
4046 spec->spdif_route = 0;
4047 #ifdef CONFIG_SND_HDA_POWER_SAVE
4048 spec->loopback.amplist = ad1882_loopbacks;
4050 spec->vmaster_nid = 0x04;
4052 codec->patch_ops = ad198x_patch_ops;
4054 /* override some parameters */
4055 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
4056 ad1882_models, NULL);
4057 switch (board_config) {
4060 spec->num_mixers = 2;
4061 spec->mixers[1] = ad1882_3stack_mixers;
4062 spec->channel_mode = ad1882_modes;
4063 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
4064 spec->need_dac_fix = 1;
4065 spec->multiout.max_channels = 2;
4066 spec->multiout.num_dacs = 1;
4069 spec->num_mixers = 2;
4070 spec->mixers[1] = ad1882_6stack_mixers;
4080 struct hda_codec_preset snd_hda_preset_analog[] = {
4081 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
4082 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
4083 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
4084 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
4085 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
4086 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
4087 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
4088 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
4089 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
4090 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
4091 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
4092 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },