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);
175 if (spec->dig_in_nid) {
176 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
181 /* if we have no master control, let's create it */
182 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
183 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
184 HDA_OUTPUT, spec->vmaster_tlv);
185 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
188 spec->slave_vols : ad_slave_vols));
192 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
193 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
196 spec->slave_sws : ad_slave_sws));
204 #ifdef CONFIG_SND_HDA_POWER_SAVE
205 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
207 struct ad198x_spec *spec = codec->spec;
208 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
213 * Analog playback callbacks
215 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
216 struct hda_codec *codec,
217 struct snd_pcm_substream *substream)
219 struct ad198x_spec *spec = codec->spec;
220 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
223 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
224 struct hda_codec *codec,
225 unsigned int stream_tag,
227 struct snd_pcm_substream *substream)
229 struct ad198x_spec *spec = codec->spec;
230 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
234 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
235 struct hda_codec *codec,
236 struct snd_pcm_substream *substream)
238 struct ad198x_spec *spec = codec->spec;
239 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
245 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
246 struct hda_codec *codec,
247 struct snd_pcm_substream *substream)
249 struct ad198x_spec *spec = codec->spec;
250 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
253 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
254 struct hda_codec *codec,
255 struct snd_pcm_substream *substream)
257 struct ad198x_spec *spec = codec->spec;
258 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
261 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
262 struct hda_codec *codec,
263 unsigned int stream_tag,
265 struct snd_pcm_substream *substream)
267 struct ad198x_spec *spec = codec->spec;
268 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
275 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
276 struct hda_codec *codec,
277 unsigned int stream_tag,
279 struct snd_pcm_substream *substream)
281 struct ad198x_spec *spec = codec->spec;
282 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
283 stream_tag, 0, format);
287 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
288 struct hda_codec *codec,
289 struct snd_pcm_substream *substream)
291 struct ad198x_spec *spec = codec->spec;
292 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
300 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
303 .channels_max = 6, /* changed later */
304 .nid = 0, /* fill later */
306 .open = ad198x_playback_pcm_open,
307 .prepare = ad198x_playback_pcm_prepare,
308 .cleanup = ad198x_playback_pcm_cleanup
312 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
316 .nid = 0, /* fill later */
318 .prepare = ad198x_capture_pcm_prepare,
319 .cleanup = ad198x_capture_pcm_cleanup
323 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
327 .nid = 0, /* fill later */
329 .open = ad198x_dig_playback_pcm_open,
330 .close = ad198x_dig_playback_pcm_close,
331 .prepare = ad198x_dig_playback_pcm_prepare
335 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
339 /* NID is set in alc_build_pcms */
342 static int ad198x_build_pcms(struct hda_codec *codec)
344 struct ad198x_spec *spec = codec->spec;
345 struct hda_pcm *info = spec->pcm_rec;
348 codec->pcm_info = info;
350 info->name = "AD198x Analog";
351 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
352 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
353 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
354 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
355 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
356 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
358 if (spec->multiout.dig_out_nid) {
361 info->name = "AD198x Digital";
362 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
363 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
364 if (spec->dig_in_nid) {
365 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
366 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
373 static void ad198x_free(struct hda_codec *codec)
375 struct ad198x_spec *spec = codec->spec;
378 if (spec->kctl_alloc) {
379 for (i = 0; i < spec->num_kctl_used; i++)
380 kfree(spec->kctl_alloc[i].name);
381 kfree(spec->kctl_alloc);
386 static struct hda_codec_ops ad198x_patch_ops = {
387 .build_controls = ad198x_build_controls,
388 .build_pcms = ad198x_build_pcms,
391 #ifdef CONFIG_SND_HDA_POWER_SAVE
392 .check_power_status = ad198x_check_power_status,
399 * the private value = nid | (invert << 8)
401 #define ad198x_eapd_info snd_ctl_boolean_mono_info
403 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
404 struct snd_ctl_elem_value *ucontrol)
406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
407 struct ad198x_spec *spec = codec->spec;
408 int invert = (kcontrol->private_value >> 8) & 1;
410 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
412 ucontrol->value.integer.value[0] = spec->cur_eapd;
416 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
417 struct snd_ctl_elem_value *ucontrol)
419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
420 struct ad198x_spec *spec = codec->spec;
421 int invert = (kcontrol->private_value >> 8) & 1;
422 hda_nid_t nid = kcontrol->private_value & 0xff;
424 eapd = !!ucontrol->value.integer.value[0];
427 if (eapd == spec->cur_eapd)
429 spec->cur_eapd = eapd;
430 snd_hda_codec_write_cache(codec, nid,
431 0, AC_VERB_SET_EAPD_BTLENABLE,
436 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
437 struct snd_ctl_elem_info *uinfo);
438 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
439 struct snd_ctl_elem_value *ucontrol);
440 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
441 struct snd_ctl_elem_value *ucontrol);
448 #define AD1986A_SPDIF_OUT 0x02
449 #define AD1986A_FRONT_DAC 0x03
450 #define AD1986A_SURR_DAC 0x04
451 #define AD1986A_CLFE_DAC 0x05
452 #define AD1986A_ADC 0x06
454 static hda_nid_t ad1986a_dac_nids[3] = {
455 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
457 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
458 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
460 static struct hda_input_mux ad1986a_capture_source = {
474 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
475 .ops = &snd_hda_bind_vol,
477 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
478 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
479 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
484 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
485 .ops = &snd_hda_bind_sw,
487 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
488 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
489 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
497 static struct snd_kcontrol_new ad1986a_mixers[] = {
499 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
501 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
502 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
503 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
504 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
505 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
506 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
507 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
508 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
509 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
510 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
511 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
512 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
513 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
514 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
515 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
516 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
517 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
518 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
519 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
520 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
521 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
522 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
523 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
524 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
525 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
526 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
527 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
529 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
530 .name = "Capture Source",
531 .info = ad198x_mux_enum_info,
532 .get = ad198x_mux_enum_get,
533 .put = ad198x_mux_enum_put,
535 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
539 /* additional mixers for 3stack mode */
540 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
542 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
543 .name = "Channel Mode",
544 .info = ad198x_ch_mode_info,
545 .get = ad198x_ch_mode_get,
546 .put = ad198x_ch_mode_put,
551 /* laptop model - 2ch only */
552 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
554 /* master controls both pins 0x1a and 0x1b */
555 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
556 .ops = &snd_hda_bind_vol,
558 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
559 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
564 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
565 .ops = &snd_hda_bind_sw,
567 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
568 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
573 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
574 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
575 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
576 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
577 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
578 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
579 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
580 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
581 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
582 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
583 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
584 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
585 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
586 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
587 /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
588 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
589 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
590 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
591 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
592 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
594 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
595 .name = "Capture Source",
596 .info = ad198x_mux_enum_info,
597 .get = ad198x_mux_enum_get,
598 .put = ad198x_mux_enum_put,
603 /* laptop-eapd model - 2ch only */
605 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
609 { "Internal Mic", 0x4 },
614 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
615 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
616 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
617 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
618 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
619 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
620 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
621 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
622 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
623 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
624 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
625 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
627 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
628 .name = "Capture Source",
629 .info = ad198x_mux_enum_info,
630 .get = ad198x_mux_enum_get,
631 .put = ad198x_mux_enum_put,
634 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
635 .name = "External Amplifier",
636 .info = ad198x_eapd_info,
637 .get = ad198x_eapd_get,
638 .put = ad198x_eapd_put,
639 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
644 /* laptop-automute - 2ch only */
646 static void ad1986a_update_hp(struct hda_codec *codec)
648 struct ad198x_spec *spec = codec->spec;
651 if (spec->jack_present)
652 mute = HDA_AMP_MUTE; /* mute internal speaker */
654 /* unmute internal speaker if necessary */
655 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
656 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
660 static void ad1986a_hp_automute(struct hda_codec *codec)
662 struct ad198x_spec *spec = codec->spec;
663 unsigned int present;
665 present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
666 /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
667 spec->jack_present = !(present & 0x80000000);
668 ad1986a_update_hp(codec);
671 #define AD1986A_HP_EVENT 0x37
673 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
675 if ((res >> 26) != AD1986A_HP_EVENT)
677 ad1986a_hp_automute(codec);
680 static int ad1986a_hp_init(struct hda_codec *codec)
683 ad1986a_hp_automute(codec);
687 /* bind hp and internal speaker mute (with plug check) */
688 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
689 struct snd_ctl_elem_value *ucontrol)
691 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
692 long *valp = ucontrol->value.integer.value;
695 change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
697 valp[0] ? 0 : HDA_AMP_MUTE);
698 change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
700 valp[1] ? 0 : HDA_AMP_MUTE);
702 ad1986a_update_hp(codec);
706 static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
707 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
709 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
710 .name = "Master Playback Switch",
711 .info = snd_hda_mixer_amp_switch_info,
712 .get = snd_hda_mixer_amp_switch_get,
713 .put = ad1986a_hp_master_sw_put,
714 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
716 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
717 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
718 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
719 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
720 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
721 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
722 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
723 HDA_CODEC_VOLUME("Beep Playback Volume", 0x18, 0x0, HDA_OUTPUT),
724 HDA_CODEC_MUTE("Beep Playback Switch", 0x18, 0x0, HDA_OUTPUT),
725 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
726 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
728 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
729 .name = "Capture Source",
730 .info = ad198x_mux_enum_info,
731 .get = ad198x_mux_enum_get,
732 .put = ad198x_mux_enum_put,
735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
736 .name = "External Amplifier",
737 .info = ad198x_eapd_info,
738 .get = ad198x_eapd_get,
739 .put = ad198x_eapd_put,
740 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
746 * initialization verbs
748 static struct hda_verb ad1986a_init_verbs[] = {
749 /* Front, Surround, CLFE DAC; mute as default */
750 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
751 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
752 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
754 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
755 /* HP, Line-Out, Surround, CLFE selectors */
756 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
757 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
758 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
759 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
761 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
762 /* Mic selector: Mic 1/2 pin */
763 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
764 /* Line-in selector: Line-in */
765 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
767 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
768 /* Record selector: mic */
769 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
770 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
771 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
772 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
773 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
774 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
775 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
777 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
778 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
779 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
780 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
781 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
782 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
783 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
785 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
786 /* Front, Surround, CLFE Pins */
787 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
788 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
789 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
791 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
793 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
794 /* Line, Aux, CD, Beep-In Pin */
795 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
796 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
797 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
798 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
799 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
803 static struct hda_verb ad1986a_ch2_init[] = {
804 /* Surround out -> Line In */
805 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
806 /* Line-in selectors */
807 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
809 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
810 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
811 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
815 static struct hda_verb ad1986a_ch4_init[] = {
816 /* Surround out -> Surround */
817 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
818 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
820 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
821 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
825 static struct hda_verb ad1986a_ch6_init[] = {
826 /* Surround out -> Surround out */
827 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
828 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
830 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
831 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
835 static struct hda_channel_mode ad1986a_modes[3] = {
836 { 2, ad1986a_ch2_init },
837 { 4, ad1986a_ch4_init },
838 { 6, ad1986a_ch6_init },
841 /* eapd initialization */
842 static struct hda_verb ad1986a_eapd_init_verbs[] = {
843 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
847 /* Ultra initialization */
848 static struct hda_verb ad1986a_ultra_init[] = {
849 /* eapd initialization */
850 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
852 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
853 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
854 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
858 /* pin sensing on HP jack */
859 static struct hda_verb ad1986a_hp_init_verbs[] = {
860 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
871 AD1986A_LAPTOP_AUTOMUTE,
876 static const char *ad1986a_models[AD1986A_MODELS] = {
877 [AD1986A_6STACK] = "6stack",
878 [AD1986A_3STACK] = "3stack",
879 [AD1986A_LAPTOP] = "laptop",
880 [AD1986A_LAPTOP_EAPD] = "laptop-eapd",
881 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
882 [AD1986A_ULTRA] = "ultra",
885 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
886 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
887 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
888 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
889 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
890 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
891 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
892 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
893 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
894 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
895 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
896 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
897 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
898 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
899 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
900 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
901 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
902 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
903 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
904 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
905 SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_LAPTOP_EAPD),
906 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_LAPTOP_EAPD),
907 SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_LAPTOP_EAPD),
908 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
909 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
910 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
911 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
912 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
913 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
917 #ifdef CONFIG_SND_HDA_POWER_SAVE
918 static struct hda_amp_list ad1986a_loopbacks[] = {
919 { 0x13, HDA_OUTPUT, 0 }, /* Mic */
920 { 0x14, HDA_OUTPUT, 0 }, /* Phone */
921 { 0x15, HDA_OUTPUT, 0 }, /* CD */
922 { 0x16, HDA_OUTPUT, 0 }, /* Aux */
923 { 0x17, HDA_OUTPUT, 0 }, /* Line */
928 static int patch_ad1986a(struct hda_codec *codec)
930 struct ad198x_spec *spec;
933 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
939 spec->multiout.max_channels = 6;
940 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
941 spec->multiout.dac_nids = ad1986a_dac_nids;
942 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
943 spec->num_adc_nids = 1;
944 spec->adc_nids = ad1986a_adc_nids;
945 spec->capsrc_nids = ad1986a_capsrc_nids;
946 spec->input_mux = &ad1986a_capture_source;
947 spec->num_mixers = 1;
948 spec->mixers[0] = ad1986a_mixers;
949 spec->num_init_verbs = 1;
950 spec->init_verbs[0] = ad1986a_init_verbs;
951 #ifdef CONFIG_SND_HDA_POWER_SAVE
952 spec->loopback.amplist = ad1986a_loopbacks;
954 spec->vmaster_nid = 0x1b;
956 codec->patch_ops = ad198x_patch_ops;
958 /* override some parameters */
959 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
962 switch (board_config) {
964 spec->num_mixers = 2;
965 spec->mixers[1] = ad1986a_3st_mixers;
966 spec->num_init_verbs = 2;
967 spec->init_verbs[1] = ad1986a_ch2_init;
968 spec->channel_mode = ad1986a_modes;
969 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
970 spec->need_dac_fix = 1;
971 spec->multiout.max_channels = 2;
972 spec->multiout.num_dacs = 1;
975 spec->mixers[0] = ad1986a_laptop_mixers;
976 spec->multiout.max_channels = 2;
977 spec->multiout.num_dacs = 1;
978 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
980 case AD1986A_LAPTOP_EAPD:
981 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
982 spec->num_init_verbs = 2;
983 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
984 spec->multiout.max_channels = 2;
985 spec->multiout.num_dacs = 1;
986 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
987 spec->multiout.dig_out_nid = 0;
988 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
990 case AD1986A_LAPTOP_AUTOMUTE:
991 spec->mixers[0] = ad1986a_laptop_automute_mixers;
992 spec->num_init_verbs = 3;
993 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
994 spec->init_verbs[2] = ad1986a_hp_init_verbs;
995 spec->multiout.max_channels = 2;
996 spec->multiout.num_dacs = 1;
997 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
998 spec->multiout.dig_out_nid = 0;
999 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1000 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1001 codec->patch_ops.init = ad1986a_hp_init;
1004 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1005 spec->num_init_verbs = 2;
1006 spec->init_verbs[1] = ad1986a_ultra_init;
1007 spec->multiout.max_channels = 2;
1008 spec->multiout.num_dacs = 1;
1009 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1010 spec->multiout.dig_out_nid = 0;
1014 /* AD1986A has a hardware problem that it can't share a stream
1015 * with multiple output pins. The copy of front to surrounds
1016 * causes noisy or silent outputs at a certain timing, e.g.
1017 * changing the volume.
1018 * So, let's disable the shared stream.
1020 spec->multiout.no_share_stream = 1;
1029 #define AD1983_SPDIF_OUT 0x02
1030 #define AD1983_DAC 0x03
1031 #define AD1983_ADC 0x04
1033 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1034 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1035 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1037 static struct hda_input_mux ad1983_capture_source = {
1043 { "Mix Mono", 0x3 },
1048 * SPDIF playback route
1050 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1052 static char *texts[] = { "PCM", "ADC" };
1054 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1056 uinfo->value.enumerated.items = 2;
1057 if (uinfo->value.enumerated.item > 1)
1058 uinfo->value.enumerated.item = 1;
1059 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1063 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1065 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1066 struct ad198x_spec *spec = codec->spec;
1068 ucontrol->value.enumerated.item[0] = spec->spdif_route;
1072 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1074 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1075 struct ad198x_spec *spec = codec->spec;
1077 if (ucontrol->value.enumerated.item[0] > 1)
1079 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1080 spec->spdif_route = ucontrol->value.enumerated.item[0];
1081 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1082 AC_VERB_SET_CONNECT_SEL,
1089 static struct snd_kcontrol_new ad1983_mixers[] = {
1090 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1091 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1092 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1093 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1094 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1095 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1096 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1097 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1098 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1099 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1100 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1101 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1102 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT),
1103 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT),
1104 HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1105 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1106 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1108 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1109 .name = "Capture Source",
1110 .info = ad198x_mux_enum_info,
1111 .get = ad198x_mux_enum_get,
1112 .put = ad198x_mux_enum_put,
1115 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1116 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1117 .info = ad1983_spdif_route_info,
1118 .get = ad1983_spdif_route_get,
1119 .put = ad1983_spdif_route_put,
1124 static struct hda_verb ad1983_init_verbs[] = {
1125 /* Front, HP, Mono; mute as default */
1126 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1127 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1128 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1129 /* Beep, PCM, Mic, Line-In: mute */
1130 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1131 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1132 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1133 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1134 /* Front, HP selectors; from Mix */
1135 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1136 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1137 /* Mono selector; from Mix */
1138 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1139 /* Mic selector; Mic */
1140 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1141 /* Line-in selector: Line-in */
1142 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1143 /* Mic boost: 0dB */
1144 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1145 /* Record selector: mic */
1146 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1147 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1148 /* SPDIF route: PCM */
1149 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1151 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1153 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1155 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1157 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1159 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1163 #ifdef CONFIG_SND_HDA_POWER_SAVE
1164 static struct hda_amp_list ad1983_loopbacks[] = {
1165 { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1166 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1171 static int patch_ad1983(struct hda_codec *codec)
1173 struct ad198x_spec *spec;
1175 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1181 spec->multiout.max_channels = 2;
1182 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1183 spec->multiout.dac_nids = ad1983_dac_nids;
1184 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1185 spec->num_adc_nids = 1;
1186 spec->adc_nids = ad1983_adc_nids;
1187 spec->capsrc_nids = ad1983_capsrc_nids;
1188 spec->input_mux = &ad1983_capture_source;
1189 spec->num_mixers = 1;
1190 spec->mixers[0] = ad1983_mixers;
1191 spec->num_init_verbs = 1;
1192 spec->init_verbs[0] = ad1983_init_verbs;
1193 spec->spdif_route = 0;
1194 #ifdef CONFIG_SND_HDA_POWER_SAVE
1195 spec->loopback.amplist = ad1983_loopbacks;
1197 spec->vmaster_nid = 0x05;
1199 codec->patch_ops = ad198x_patch_ops;
1206 * AD1981 HD specific
1209 #define AD1981_SPDIF_OUT 0x02
1210 #define AD1981_DAC 0x03
1211 #define AD1981_ADC 0x04
1213 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1214 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1215 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1217 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1218 static struct hda_input_mux ad1981_capture_source = {
1221 { "Front Mic", 0x0 },
1224 { "Mix Mono", 0x3 },
1231 static struct snd_kcontrol_new ad1981_mixers[] = {
1232 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1233 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1234 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1235 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1236 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1237 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1238 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1239 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1240 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1241 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1242 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1243 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1244 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1245 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1246 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1247 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1248 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1249 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1250 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1251 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT),
1252 HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1253 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
1254 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1255 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1257 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1258 .name = "Capture Source",
1259 .info = ad198x_mux_enum_info,
1260 .get = ad198x_mux_enum_get,
1261 .put = ad198x_mux_enum_put,
1263 /* identical with AD1983 */
1265 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1266 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1267 .info = ad1983_spdif_route_info,
1268 .get = ad1983_spdif_route_get,
1269 .put = ad1983_spdif_route_put,
1274 static struct hda_verb ad1981_init_verbs[] = {
1275 /* Front, HP, Mono; mute as default */
1276 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1277 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1278 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1279 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1280 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1281 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1282 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1283 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1284 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1285 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1286 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1287 /* Front, HP selectors; from Mix */
1288 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1289 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1290 /* Mono selector; from Mix */
1291 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1292 /* Mic Mixer; select Front Mic */
1293 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1294 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1295 /* Mic boost: 0dB */
1296 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1297 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1298 /* Record selector: Front mic */
1299 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1300 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1301 /* SPDIF route: PCM */
1302 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1304 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1306 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1308 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1309 /* Front & Rear Mic Pins */
1310 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1311 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1313 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1315 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1316 /* Line-Out as Input: disabled */
1317 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1321 #ifdef CONFIG_SND_HDA_POWER_SAVE
1322 static struct hda_amp_list ad1981_loopbacks[] = {
1323 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1324 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1325 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1326 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1327 { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1333 * Patch for HP nx6320
1335 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1336 * speaker output enabled _and_ mute-LED off.
1339 #define AD1981_HP_EVENT 0x37
1340 #define AD1981_MIC_EVENT 0x38
1342 static struct hda_verb ad1981_hp_init_verbs[] = {
1343 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1344 /* pin sensing on HP and Mic jacks */
1345 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1346 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1350 /* turn on/off EAPD (+ mute HP) as a master switch */
1351 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1352 struct snd_ctl_elem_value *ucontrol)
1354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1355 struct ad198x_spec *spec = codec->spec;
1357 if (! ad198x_eapd_put(kcontrol, ucontrol))
1360 /* toggle HP mute appropriately */
1361 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1363 spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1367 /* bind volumes of both NID 0x05 and 0x06 */
1368 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1369 .ops = &snd_hda_bind_vol,
1371 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1372 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1377 /* mute internal speaker if HP is plugged */
1378 static void ad1981_hp_automute(struct hda_codec *codec)
1380 unsigned int present;
1382 present = snd_hda_codec_read(codec, 0x06, 0,
1383 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1384 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1385 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1388 /* toggle input of built-in and mic jack appropriately */
1389 static void ad1981_hp_automic(struct hda_codec *codec)
1391 static struct hda_verb mic_jack_on[] = {
1392 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1393 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1396 static struct hda_verb mic_jack_off[] = {
1397 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1398 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1401 unsigned int present;
1403 present = snd_hda_codec_read(codec, 0x08, 0,
1404 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1406 snd_hda_sequence_write(codec, mic_jack_on);
1408 snd_hda_sequence_write(codec, mic_jack_off);
1411 /* unsolicited event for HP jack sensing */
1412 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1417 case AD1981_HP_EVENT:
1418 ad1981_hp_automute(codec);
1420 case AD1981_MIC_EVENT:
1421 ad1981_hp_automic(codec);
1426 static struct hda_input_mux ad1981_hp_capture_source = {
1430 { "Docking-Station", 0x1 },
1435 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1436 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1438 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1439 .name = "Master Playback Switch",
1440 .info = ad198x_eapd_info,
1441 .get = ad198x_eapd_get,
1442 .put = ad1981_hp_master_sw_put,
1443 .private_value = 0x05,
1445 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1446 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1448 /* FIXME: analog mic/line loopback doesn't work with my tests...
1449 * (although recording is OK)
1451 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1452 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1453 HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1454 HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1455 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1456 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1457 /* FIXME: does this laptop have analog CD connection? */
1458 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1459 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1461 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1462 HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1463 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1464 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1466 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1467 .name = "Capture Source",
1468 .info = ad198x_mux_enum_info,
1469 .get = ad198x_mux_enum_get,
1470 .put = ad198x_mux_enum_put,
1475 /* initialize jack-sensing, too */
1476 static int ad1981_hp_init(struct hda_codec *codec)
1479 ad1981_hp_automute(codec);
1480 ad1981_hp_automic(codec);
1484 /* configuration for Toshiba Laptops */
1485 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1486 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1487 /* pin sensing on HP and Mic jacks */
1488 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1489 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1493 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1494 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1495 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1499 /* configuration for Lenovo Thinkpad T60 */
1500 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1501 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1502 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1503 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1504 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1505 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1506 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1507 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1508 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1509 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1510 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1511 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1513 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1514 .name = "Capture Source",
1515 .info = ad198x_mux_enum_info,
1516 .get = ad198x_mux_enum_get,
1517 .put = ad198x_mux_enum_put,
1519 /* identical with AD1983 */
1521 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1522 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1523 .info = ad1983_spdif_route_info,
1524 .get = ad1983_spdif_route_get,
1525 .put = ad1983_spdif_route_put,
1530 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1548 static const char *ad1981_models[AD1981_MODELS] = {
1550 [AD1981_THINKPAD] = "thinkpad",
1551 [AD1981_BASIC] = "basic",
1552 [AD1981_TOSHIBA] = "toshiba"
1555 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1556 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1558 SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
1559 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1560 /* Lenovo Thinkpad T60/X60/Z6xx */
1561 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
1562 /* HP nx6320 (reversed SSID, H/W bug) */
1563 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1567 static int patch_ad1981(struct hda_codec *codec)
1569 struct ad198x_spec *spec;
1572 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1578 spec->multiout.max_channels = 2;
1579 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1580 spec->multiout.dac_nids = ad1981_dac_nids;
1581 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1582 spec->num_adc_nids = 1;
1583 spec->adc_nids = ad1981_adc_nids;
1584 spec->capsrc_nids = ad1981_capsrc_nids;
1585 spec->input_mux = &ad1981_capture_source;
1586 spec->num_mixers = 1;
1587 spec->mixers[0] = ad1981_mixers;
1588 spec->num_init_verbs = 1;
1589 spec->init_verbs[0] = ad1981_init_verbs;
1590 spec->spdif_route = 0;
1591 #ifdef CONFIG_SND_HDA_POWER_SAVE
1592 spec->loopback.amplist = ad1981_loopbacks;
1594 spec->vmaster_nid = 0x05;
1596 codec->patch_ops = ad198x_patch_ops;
1598 /* override some parameters */
1599 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1602 switch (board_config) {
1604 spec->mixers[0] = ad1981_hp_mixers;
1605 spec->num_init_verbs = 2;
1606 spec->init_verbs[1] = ad1981_hp_init_verbs;
1607 spec->multiout.dig_out_nid = 0;
1608 spec->input_mux = &ad1981_hp_capture_source;
1610 codec->patch_ops.init = ad1981_hp_init;
1611 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1613 case AD1981_THINKPAD:
1614 spec->mixers[0] = ad1981_thinkpad_mixers;
1615 spec->input_mux = &ad1981_thinkpad_capture_source;
1617 case AD1981_TOSHIBA:
1618 spec->mixers[0] = ad1981_hp_mixers;
1619 spec->mixers[1] = ad1981_toshiba_mixers;
1620 spec->num_init_verbs = 2;
1621 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1622 spec->multiout.dig_out_nid = 0;
1623 spec->input_mux = &ad1981_hp_capture_source;
1624 codec->patch_ops.init = ad1981_hp_init;
1625 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1635 * Output pins and routes
1637 * Pin Mix Sel DAC (*)
1638 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1639 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1640 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
1641 * port-D 0x12 (mute/hp) <- 0x29 <- 04
1642 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1643 * port-F 0x16 (mute) <- 0x2a <- 06
1644 * port-G 0x24 (mute) <- 0x27 <- 05
1645 * port-H 0x25 (mute) <- 0x28 <- 0a
1646 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1648 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1649 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1651 * Input pins and routes
1653 * pin boost mix input # / adc input #
1654 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1655 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1656 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1657 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1658 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1659 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1660 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1661 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1665 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1666 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1668 * Inputs of Analog Mix (0x20)
1669 * 0:Port-B (front mic)
1670 * 1:Port-C/G/H (line-in)
1672 * 3:Port-D (line-in/2)
1673 * 4:Port-E/G/H (mic-in)
1674 * 5:Port-F (mic2-in)
1680 * 1:Port-B (front mic-in)
1681 * 2:Port-C (line-in)
1682 * 3:Port-F (mic2-in)
1687 * 8:Port-D (line-in/2)
1690 * Proposed pin assignments by the datasheet
1693 * Port-A front headphone
1703 * Port-A front headphone
1705 * C rear line-in/surround
1707 * E rear mic-in/CLFE
1713 * D internal speaker (with EAPD)
1714 * E/F quad mic array
1730 /* reivision id to check workarounds */
1731 #define AD1988A_REV2 0x100200
1733 #define is_rev2(codec) \
1734 ((codec)->vendor_id == 0x11d41988 && \
1735 (codec)->revision_id == AD1988A_REV2)
1741 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1742 0x04, 0x06, 0x05, 0x0a
1745 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1749 /* for AD1988A revision-2, DAC2-4 are swapped */
1750 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1751 0x04, 0x05, 0x0a, 0x06
1754 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1758 static hda_nid_t ad1988_adc_nids[3] = {
1762 static hda_nid_t ad1988_capsrc_nids[3] = {
1766 #define AD1988_SPDIF_OUT 0x02
1767 #define AD1988_SPDIF_IN 0x07
1769 static struct hda_input_mux ad1988_6stack_capture_source = {
1772 { "Front Mic", 0x0 },
1780 static struct hda_input_mux ad1988_laptop_capture_source = {
1783 { "Mic/Line", 0x0 },
1791 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1792 struct snd_ctl_elem_info *uinfo)
1794 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1795 struct ad198x_spec *spec = codec->spec;
1796 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1797 spec->num_channel_mode);
1800 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
1801 struct snd_ctl_elem_value *ucontrol)
1803 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1804 struct ad198x_spec *spec = codec->spec;
1805 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
1806 spec->num_channel_mode, spec->multiout.max_channels);
1809 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
1810 struct snd_ctl_elem_value *ucontrol)
1812 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1813 struct ad198x_spec *spec = codec->spec;
1814 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
1815 spec->num_channel_mode,
1816 &spec->multiout.max_channels);
1817 if (err >= 0 && spec->need_dac_fix)
1818 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1823 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
1824 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1825 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1826 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1827 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1828 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1832 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
1833 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1834 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1835 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
1836 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
1837 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1841 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
1842 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1843 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
1844 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
1845 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
1846 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
1847 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1848 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1850 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1851 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1852 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1853 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1854 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1855 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1856 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1857 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1859 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1860 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1862 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1863 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1865 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1866 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1872 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
1873 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1874 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1875 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1876 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1880 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
1881 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1882 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1883 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
1884 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
1888 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
1889 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1890 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
1891 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
1892 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
1893 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1894 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1896 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1897 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1898 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1899 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1900 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1901 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1902 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1903 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1905 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1906 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1908 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1909 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1911 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1912 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1914 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1915 .name = "Channel Mode",
1916 .info = ad198x_ch_mode_info,
1917 .get = ad198x_ch_mode_get,
1918 .put = ad198x_ch_mode_put,
1925 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
1926 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1927 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
1928 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1930 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1931 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1932 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1933 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1934 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1935 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1937 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1938 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1940 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1941 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1943 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1946 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1947 .name = "External Amplifier",
1948 .info = ad198x_eapd_info,
1949 .get = ad198x_eapd_get,
1950 .put = ad198x_eapd_put,
1951 .private_value = 0x12 | (1 << 8), /* port-D, inversed */
1958 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
1959 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
1960 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
1961 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
1962 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
1963 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
1964 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
1966 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1967 /* The multiple "Capture Source" controls confuse alsamixer
1968 * So call somewhat different..
1970 /* .name = "Capture Source", */
1971 .name = "Input Source",
1973 .info = ad198x_mux_enum_info,
1974 .get = ad198x_mux_enum_get,
1975 .put = ad198x_mux_enum_put,
1980 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
1981 struct snd_ctl_elem_info *uinfo)
1983 static char *texts[] = {
1984 "PCM", "ADC1", "ADC2", "ADC3"
1986 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1988 uinfo->value.enumerated.items = 4;
1989 if (uinfo->value.enumerated.item >= 4)
1990 uinfo->value.enumerated.item = 3;
1991 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1995 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
1996 struct snd_ctl_elem_value *ucontrol)
1998 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2001 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2004 ucontrol->value.enumerated.item[0] = 0;
2006 sel = snd_hda_codec_read(codec, 0x0b, 0,
2007 AC_VERB_GET_CONNECT_SEL, 0);
2012 ucontrol->value.enumerated.item[0] = sel;
2017 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2018 struct snd_ctl_elem_value *ucontrol)
2020 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2021 unsigned int val, sel;
2024 val = ucontrol->value.enumerated.item[0];
2028 sel = snd_hda_codec_read(codec, 0x1d, 0,
2029 AC_VERB_GET_AMP_GAIN_MUTE,
2031 change = sel & 0x80;
2033 snd_hda_codec_write_cache(codec, 0x1d, 0,
2034 AC_VERB_SET_AMP_GAIN_MUTE,
2036 snd_hda_codec_write_cache(codec, 0x1d, 0,
2037 AC_VERB_SET_AMP_GAIN_MUTE,
2041 sel = snd_hda_codec_read(codec, 0x1d, 0,
2042 AC_VERB_GET_AMP_GAIN_MUTE,
2043 AC_AMP_GET_INPUT | 0x01);
2044 change = sel & 0x80;
2046 snd_hda_codec_write_cache(codec, 0x1d, 0,
2047 AC_VERB_SET_AMP_GAIN_MUTE,
2049 snd_hda_codec_write_cache(codec, 0x1d, 0,
2050 AC_VERB_SET_AMP_GAIN_MUTE,
2053 sel = snd_hda_codec_read(codec, 0x0b, 0,
2054 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2055 change |= sel != val;
2057 snd_hda_codec_write_cache(codec, 0x0b, 0,
2058 AC_VERB_SET_CONNECT_SEL,
2064 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2065 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2067 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2068 .name = "IEC958 Playback Source",
2069 .info = ad1988_spdif_playback_source_info,
2070 .get = ad1988_spdif_playback_source_get,
2071 .put = ad1988_spdif_playback_source_put,
2076 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2077 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2083 * initialization verbs
2087 * for 6-stack (+dig)
2089 static struct hda_verb ad1988_6stack_init_verbs[] = {
2090 /* Front, Surround, CLFE, side DAC; unmute as default */
2091 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2092 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2093 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2094 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2095 /* Port-A front headphon path */
2096 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2097 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2098 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2099 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2100 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2101 /* Port-D line-out path */
2102 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2103 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2104 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2105 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2106 /* Port-F surround path */
2107 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2108 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2109 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2110 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2111 /* Port-G CLFE path */
2112 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2113 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2114 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2115 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2116 /* Port-H side path */
2117 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2118 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2119 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2120 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2122 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2123 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2124 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2125 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2126 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2127 /* Port-B front mic-in path */
2128 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2129 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2130 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2131 /* Port-C line-in path */
2132 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2133 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2134 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2135 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2136 /* Port-E mic-in path */
2137 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2138 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2139 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2140 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2141 /* Analog CD Input */
2142 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2147 static struct hda_verb ad1988_capture_init_verbs[] = {
2148 /* mute analog mix */
2149 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2150 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2151 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2152 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2153 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2154 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2155 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2156 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2157 /* select ADCs - front-mic */
2158 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2159 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2160 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2162 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2163 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2164 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2169 static struct hda_verb ad1988_spdif_init_verbs[] = {
2171 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2172 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2173 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2174 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2176 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2182 * verbs for 3stack (+dig)
2184 static struct hda_verb ad1988_3stack_ch2_init[] = {
2185 /* set port-C to line-in */
2186 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2187 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2188 /* set port-E to mic-in */
2189 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2190 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2194 static struct hda_verb ad1988_3stack_ch6_init[] = {
2195 /* set port-C to surround out */
2196 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2197 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2198 /* set port-E to CLFE out */
2199 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2200 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2204 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2205 { 2, ad1988_3stack_ch2_init },
2206 { 6, ad1988_3stack_ch6_init },
2209 static struct hda_verb ad1988_3stack_init_verbs[] = {
2210 /* Front, Surround, CLFE, side DAC; unmute as default */
2211 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2212 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2213 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2214 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2215 /* Port-A front headphon path */
2216 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2217 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2218 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2219 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2220 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2221 /* Port-D line-out path */
2222 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2223 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2224 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2225 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2227 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2228 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2229 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2230 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2231 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2232 /* Port-B front mic-in path */
2233 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2234 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2235 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2236 /* Port-C line-in/surround path - 6ch mode as default */
2237 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2238 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2239 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2240 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2241 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2242 /* Port-E mic-in/CLFE path - 6ch mode as default */
2243 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2244 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2245 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2246 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2247 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2248 /* mute analog mix */
2249 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2250 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2251 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2252 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2253 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2254 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2255 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2256 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2257 /* select ADCs - front-mic */
2258 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2259 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2260 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2262 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2263 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2264 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2269 * verbs for laptop mode (+dig)
2271 static struct hda_verb ad1988_laptop_hp_on[] = {
2272 /* unmute port-A and mute port-D */
2273 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2274 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2277 static struct hda_verb ad1988_laptop_hp_off[] = {
2278 /* mute port-A and unmute port-D */
2279 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2280 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2284 #define AD1988_HP_EVENT 0x01
2286 static struct hda_verb ad1988_laptop_init_verbs[] = {
2287 /* Front, Surround, CLFE, side DAC; unmute as default */
2288 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2289 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2290 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2291 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2292 /* Port-A front headphon path */
2293 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2294 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2295 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2296 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2297 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2298 /* unsolicited event for pin-sense */
2299 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2300 /* Port-D line-out path + EAPD */
2301 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2302 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2303 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2304 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2305 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2307 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2308 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2309 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2310 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2311 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2312 /* Port-B mic-in path */
2313 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2314 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2315 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2316 /* Port-C docking station - try to output */
2317 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2318 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2319 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2320 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2321 /* mute analog mix */
2322 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2323 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2324 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2325 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2326 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2327 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2328 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2329 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2330 /* select ADCs - mic */
2331 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2332 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2333 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2335 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2336 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2337 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2341 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2343 if ((res >> 26) != AD1988_HP_EVENT)
2345 if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
2346 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2348 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2351 #ifdef CONFIG_SND_HDA_POWER_SAVE
2352 static struct hda_amp_list ad1988_loopbacks[] = {
2353 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2354 { 0x20, HDA_INPUT, 1 }, /* Line */
2355 { 0x20, HDA_INPUT, 4 }, /* Mic */
2356 { 0x20, HDA_INPUT, 6 }, /* CD */
2362 * Automatic parse of I/O pins from the BIOS configuration
2365 #define NUM_CONTROL_ALLOC 32
2366 #define NUM_VERB_ALLOC 32
2373 static struct snd_kcontrol_new ad1988_control_templates[] = {
2374 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2375 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2376 HDA_BIND_MUTE(NULL, 0, 0, 0),
2379 /* add dynamic controls */
2380 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2383 struct snd_kcontrol_new *knew;
2385 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2386 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2388 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2391 if (spec->kctl_alloc) {
2392 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2393 kfree(spec->kctl_alloc);
2395 spec->kctl_alloc = knew;
2396 spec->num_kctl_alloc = num;
2399 knew = &spec->kctl_alloc[spec->num_kctl_used];
2400 *knew = ad1988_control_templates[type];
2401 knew->name = kstrdup(name, GFP_KERNEL);
2404 knew->private_value = val;
2405 spec->num_kctl_used++;
2409 #define AD1988_PIN_CD_NID 0x18
2410 #define AD1988_PIN_BEEP_NID 0x10
2412 static hda_nid_t ad1988_mixer_nids[8] = {
2413 /* A B C D E F G H */
2414 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2417 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2419 static hda_nid_t idx_to_dac[8] = {
2420 /* A B C D E F G H */
2421 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2423 static hda_nid_t idx_to_dac_rev2[8] = {
2424 /* A B C D E F G H */
2425 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2428 return idx_to_dac_rev2[idx];
2430 return idx_to_dac[idx];
2433 static hda_nid_t ad1988_boost_nids[8] = {
2434 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2437 static int ad1988_pin_idx(hda_nid_t nid)
2439 static hda_nid_t ad1988_io_pins[8] = {
2440 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2443 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2444 if (ad1988_io_pins[i] == nid)
2446 return 0; /* should be -1 */
2449 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2451 static int loopback_idx[8] = {
2452 2, 0, 1, 3, 4, 5, 1, 4
2455 case AD1988_PIN_CD_NID:
2458 return loopback_idx[ad1988_pin_idx(nid)];
2462 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2464 static int adc_idx[8] = {
2465 0, 1, 2, 8, 4, 3, 6, 7
2468 case AD1988_PIN_CD_NID:
2471 return adc_idx[ad1988_pin_idx(nid)];
2475 /* fill in the dac_nids table from the parsed pin configuration */
2476 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2477 const struct auto_pin_cfg *cfg)
2479 struct ad198x_spec *spec = codec->spec;
2482 spec->multiout.dac_nids = spec->private_dac_nids;
2484 /* check the pins hardwired to audio widget */
2485 for (i = 0; i < cfg->line_outs; i++) {
2486 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2487 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2489 spec->multiout.num_dacs = cfg->line_outs;
2493 /* add playback controls from the parsed DAC table */
2494 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2495 const struct auto_pin_cfg *cfg)
2498 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2502 for (i = 0; i < cfg->line_outs; i++) {
2503 hda_nid_t dac = spec->multiout.dac_nids[i];
2506 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2509 err = add_control(spec, AD_CTL_WIDGET_VOL,
2510 "Center Playback Volume",
2511 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2514 err = add_control(spec, AD_CTL_WIDGET_VOL,
2515 "LFE Playback Volume",
2516 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2519 err = add_control(spec, AD_CTL_BIND_MUTE,
2520 "Center Playback Switch",
2521 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2524 err = add_control(spec, AD_CTL_BIND_MUTE,
2525 "LFE Playback Switch",
2526 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2530 sprintf(name, "%s Playback Volume", chname[i]);
2531 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2532 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2535 sprintf(name, "%s Playback Switch", chname[i]);
2536 err = add_control(spec, AD_CTL_BIND_MUTE, name,
2537 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2545 /* add playback controls for speaker and HP outputs */
2546 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2549 struct ad198x_spec *spec = codec->spec;
2557 idx = ad1988_pin_idx(pin);
2558 nid = ad1988_idx_to_dac(codec, idx);
2559 /* specify the DAC as the extra output */
2560 if (! spec->multiout.hp_nid)
2561 spec->multiout.hp_nid = nid;
2563 spec->multiout.extra_out_nid[0] = nid;
2564 /* control HP volume/switch on the output mixer amp */
2565 sprintf(name, "%s Playback Volume", pfx);
2566 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2567 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2569 nid = ad1988_mixer_nids[idx];
2570 sprintf(name, "%s Playback Switch", pfx);
2571 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2572 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2577 /* create input playback/capture controls for the given pin */
2578 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2579 const char *ctlname, int boost)
2584 sprintf(name, "%s Playback Volume", ctlname);
2585 idx = ad1988_pin_to_loopback_idx(pin);
2586 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2587 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2589 sprintf(name, "%s Playback Switch", ctlname);
2590 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2591 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2595 idx = ad1988_pin_idx(pin);
2596 bnid = ad1988_boost_nids[idx];
2598 sprintf(name, "%s Boost", ctlname);
2599 return add_control(spec, AD_CTL_WIDGET_VOL, name,
2600 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2607 /* create playback/capture controls for input pins */
2608 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2609 const struct auto_pin_cfg *cfg)
2611 struct hda_input_mux *imux = &spec->private_imux;
2614 for (i = 0; i < AUTO_PIN_LAST; i++) {
2615 err = new_analog_input(spec, cfg->input_pins[i],
2616 auto_pin_cfg_labels[i],
2617 i <= AUTO_PIN_FRONT_MIC);
2620 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2621 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2624 imux->items[imux->num_items].label = "Mix";
2625 imux->items[imux->num_items].index = 9;
2628 if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2629 "Analog Mix Playback Volume",
2630 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2632 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2633 "Analog Mix Playback Switch",
2634 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2640 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2641 hda_nid_t nid, int pin_type,
2645 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2646 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2648 case 0x11: /* port-A - DAC 04 */
2649 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2651 case 0x14: /* port-B - DAC 06 */
2652 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2654 case 0x15: /* port-C - DAC 05 */
2655 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2657 case 0x17: /* port-E - DAC 0a */
2658 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2660 case 0x13: /* mono - DAC 04 */
2661 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2666 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2668 struct ad198x_spec *spec = codec->spec;
2671 for (i = 0; i < spec->autocfg.line_outs; i++) {
2672 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2673 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2677 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2679 struct ad198x_spec *spec = codec->spec;
2682 pin = spec->autocfg.speaker_pins[0];
2683 if (pin) /* connect to front */
2684 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2685 pin = spec->autocfg.hp_pins[0];
2686 if (pin) /* connect to front */
2687 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2690 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2692 struct ad198x_spec *spec = codec->spec;
2695 for (i = 0; i < AUTO_PIN_LAST; i++) {
2696 hda_nid_t nid = spec->autocfg.input_pins[i];
2700 case 0x15: /* port-C */
2701 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2703 case 0x17: /* port-E */
2704 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2707 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2708 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2709 if (nid != AD1988_PIN_CD_NID)
2710 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2712 idx = ad1988_pin_idx(nid);
2713 if (ad1988_boost_nids[idx])
2714 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2715 AC_VERB_SET_AMP_GAIN_MUTE,
2720 /* parse the BIOS configuration and set up the alc_spec */
2721 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2722 static int ad1988_parse_auto_config(struct hda_codec *codec)
2724 struct ad198x_spec *spec = codec->spec;
2727 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2729 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2731 if (! spec->autocfg.line_outs)
2732 return 0; /* can't find valid BIOS pin config */
2733 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2734 (err = ad1988_auto_create_extra_out(codec,
2735 spec->autocfg.speaker_pins[0],
2737 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2738 "Headphone")) < 0 ||
2739 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2742 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2744 if (spec->autocfg.dig_out_pin)
2745 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2746 if (spec->autocfg.dig_in_pin)
2747 spec->dig_in_nid = AD1988_SPDIF_IN;
2749 if (spec->kctl_alloc)
2750 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2752 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2754 spec->input_mux = &spec->private_imux;
2759 /* init callback for auto-configuration model -- overriding the default init */
2760 static int ad1988_auto_init(struct hda_codec *codec)
2763 ad1988_auto_init_multi_out(codec);
2764 ad1988_auto_init_extra_out(codec);
2765 ad1988_auto_init_analog_input(codec);
2773 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2774 [AD1988_6STACK] = "6stack",
2775 [AD1988_6STACK_DIG] = "6stack-dig",
2776 [AD1988_3STACK] = "3stack",
2777 [AD1988_3STACK_DIG] = "3stack-dig",
2778 [AD1988_LAPTOP] = "laptop",
2779 [AD1988_LAPTOP_DIG] = "laptop-dig",
2780 [AD1988_AUTO] = "auto",
2783 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2784 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2785 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2789 static int patch_ad1988(struct hda_codec *codec)
2791 struct ad198x_spec *spec;
2794 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2801 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
2803 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
2804 ad1988_models, ad1988_cfg_tbl);
2805 if (board_config < 0) {
2806 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
2807 board_config = AD1988_AUTO;
2810 if (board_config == AD1988_AUTO) {
2811 /* automatic parse from the BIOS config */
2812 int err = ad1988_parse_auto_config(codec);
2817 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n");
2818 board_config = AD1988_6STACK;
2822 switch (board_config) {
2824 case AD1988_6STACK_DIG:
2825 spec->multiout.max_channels = 8;
2826 spec->multiout.num_dacs = 4;
2828 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
2830 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
2831 spec->input_mux = &ad1988_6stack_capture_source;
2832 spec->num_mixers = 2;
2834 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
2836 spec->mixers[0] = ad1988_6stack_mixers1;
2837 spec->mixers[1] = ad1988_6stack_mixers2;
2838 spec->num_init_verbs = 1;
2839 spec->init_verbs[0] = ad1988_6stack_init_verbs;
2840 if (board_config == AD1988_6STACK_DIG) {
2841 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2842 spec->dig_in_nid = AD1988_SPDIF_IN;
2846 case AD1988_3STACK_DIG:
2847 spec->multiout.max_channels = 6;
2848 spec->multiout.num_dacs = 3;
2850 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
2852 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2853 spec->input_mux = &ad1988_6stack_capture_source;
2854 spec->channel_mode = ad1988_3stack_modes;
2855 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
2856 spec->num_mixers = 2;
2858 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
2860 spec->mixers[0] = ad1988_3stack_mixers1;
2861 spec->mixers[1] = ad1988_3stack_mixers2;
2862 spec->num_init_verbs = 1;
2863 spec->init_verbs[0] = ad1988_3stack_init_verbs;
2864 if (board_config == AD1988_3STACK_DIG)
2865 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2868 case AD1988_LAPTOP_DIG:
2869 spec->multiout.max_channels = 2;
2870 spec->multiout.num_dacs = 1;
2871 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2872 spec->input_mux = &ad1988_laptop_capture_source;
2873 spec->num_mixers = 1;
2874 spec->mixers[0] = ad1988_laptop_mixers;
2875 spec->num_init_verbs = 1;
2876 spec->init_verbs[0] = ad1988_laptop_init_verbs;
2877 if (board_config == AD1988_LAPTOP_DIG)
2878 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2882 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
2883 spec->adc_nids = ad1988_adc_nids;
2884 spec->capsrc_nids = ad1988_capsrc_nids;
2885 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
2886 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
2887 if (spec->multiout.dig_out_nid) {
2888 spec->mixers[spec->num_mixers++] = ad1988_spdif_out_mixers;
2889 spec->init_verbs[spec->num_init_verbs++] = ad1988_spdif_init_verbs;
2891 if (spec->dig_in_nid)
2892 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
2894 codec->patch_ops = ad198x_patch_ops;
2895 switch (board_config) {
2897 codec->patch_ops.init = ad1988_auto_init;
2900 case AD1988_LAPTOP_DIG:
2901 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
2904 #ifdef CONFIG_SND_HDA_POWER_SAVE
2905 spec->loopback.amplist = ad1988_loopbacks;
2907 spec->vmaster_nid = 0x04;
2916 * port-B - front line/mic-in
2917 * port-E - aux in/out
2918 * port-F - aux in/out
2919 * port-C - rear line/mic-in
2920 * port-D - rear line/hp-out
2921 * port-A - front line/hp-out
2923 * AD1984 = AD1884 + two digital mic-ins
2926 * For simplicity, we share the single DAC for both HP and line-outs
2927 * right now. The inidividual playbacks could be easily implemented,
2928 * but no build-up framework is given, so far.
2931 static hda_nid_t ad1884_dac_nids[1] = {
2935 static hda_nid_t ad1884_adc_nids[2] = {
2939 static hda_nid_t ad1884_capsrc_nids[2] = {
2943 #define AD1884_SPDIF_OUT 0x02
2945 static struct hda_input_mux ad1884_capture_source = {
2948 { "Front Mic", 0x0 },
2955 static struct snd_kcontrol_new ad1884_base_mixers[] = {
2956 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2957 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
2958 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
2959 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
2960 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
2961 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
2962 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
2963 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
2964 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
2965 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
2966 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
2967 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
2969 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
2970 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
2971 HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
2972 HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2974 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
2975 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
2976 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2977 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2978 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2979 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2981 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2982 /* The multiple "Capture Source" controls confuse alsamixer
2983 * So call somewhat different..
2985 /* .name = "Capture Source", */
2986 .name = "Input Source",
2988 .info = ad198x_mux_enum_info,
2989 .get = ad198x_mux_enum_get,
2990 .put = ad198x_mux_enum_put,
2992 /* SPDIF controls */
2993 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2995 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2996 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
2997 /* identical with ad1983 */
2998 .info = ad1983_spdif_route_info,
2999 .get = ad1983_spdif_route_get,
3000 .put = ad1983_spdif_route_put,
3005 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3006 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3007 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3008 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3010 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3016 * initialization verbs
3018 static struct hda_verb ad1884_init_verbs[] = {
3019 /* DACs; mute as default */
3020 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3021 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3022 /* Port-A (HP) mixer */
3023 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3024 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3026 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3027 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3028 /* HP selector - select DAC2 */
3029 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3030 /* Port-D (Line-out) mixer */
3031 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3032 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3034 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3035 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3036 /* Mono-out mixer */
3037 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3038 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3040 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3041 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3043 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3044 /* Port-B (front mic) pin */
3045 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3046 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3047 /* Port-C (rear mic) pin */
3048 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3049 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3050 /* Analog mixer; mute as default */
3051 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3052 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3053 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3054 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3055 /* Analog Mix output amp */
3056 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3057 /* SPDIF output selector */
3058 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3059 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3063 #ifdef CONFIG_SND_HDA_POWER_SAVE
3064 static struct hda_amp_list ad1884_loopbacks[] = {
3065 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3066 { 0x20, HDA_INPUT, 1 }, /* Mic */
3067 { 0x20, HDA_INPUT, 2 }, /* CD */
3068 { 0x20, HDA_INPUT, 4 }, /* Docking */
3073 static const char *ad1884_slave_vols[] = {
3074 "PCM Playback Volume",
3075 "Mic Playback Volume",
3076 "Mono Playback Volume",
3077 "Front Mic Playback Volume",
3078 "Mic Playback Volume",
3079 "CD Playback Volume",
3080 "Internal Mic Playback Volume",
3081 "Docking Mic Playback Volume"
3082 "Beep Playback Volume",
3083 "IEC958 Playback Volume",
3087 static int patch_ad1884(struct hda_codec *codec)
3089 struct ad198x_spec *spec;
3091 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3095 mutex_init(&spec->amp_mutex);
3098 spec->multiout.max_channels = 2;
3099 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3100 spec->multiout.dac_nids = ad1884_dac_nids;
3101 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3102 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3103 spec->adc_nids = ad1884_adc_nids;
3104 spec->capsrc_nids = ad1884_capsrc_nids;
3105 spec->input_mux = &ad1884_capture_source;
3106 spec->num_mixers = 1;
3107 spec->mixers[0] = ad1884_base_mixers;
3108 spec->num_init_verbs = 1;
3109 spec->init_verbs[0] = ad1884_init_verbs;
3110 spec->spdif_route = 0;
3111 #ifdef CONFIG_SND_HDA_POWER_SAVE
3112 spec->loopback.amplist = ad1884_loopbacks;
3114 spec->vmaster_nid = 0x04;
3115 /* we need to cover all playback volumes */
3116 spec->slave_vols = ad1884_slave_vols;
3118 codec->patch_ops = ad198x_patch_ops;
3124 * Lenovo Thinkpad T61/X61
3126 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3130 { "Internal Mic", 0x1 },
3135 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3136 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3137 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3138 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3139 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3140 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3141 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3142 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3143 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3144 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3145 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3146 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3147 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3148 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3149 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3150 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3151 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3152 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3153 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3154 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3156 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3157 /* The multiple "Capture Source" controls confuse alsamixer
3158 * So call somewhat different..
3160 /* .name = "Capture Source", */
3161 .name = "Input Source",
3163 .info = ad198x_mux_enum_info,
3164 .get = ad198x_mux_enum_get,
3165 .put = ad198x_mux_enum_put,
3167 /* SPDIF controls */
3168 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3170 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3171 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3172 /* identical with ad1983 */
3173 .info = ad1983_spdif_route_info,
3174 .get = ad1983_spdif_route_get,
3175 .put = ad1983_spdif_route_put,
3180 /* additional verbs */
3181 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3182 /* Port-E (docking station mic) pin */
3183 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3184 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3185 /* docking mic boost */
3186 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3187 /* Analog mixer - docking mic; mute as default */
3188 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3189 /* enable EAPD bit */
3190 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3194 /* Digial MIC ADC NID 0x05 + 0x06 */
3195 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3196 struct hda_codec *codec,
3197 unsigned int stream_tag,
3198 unsigned int format,
3199 struct snd_pcm_substream *substream)
3201 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3202 stream_tag, 0, format);
3206 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3207 struct hda_codec *codec,
3208 struct snd_pcm_substream *substream)
3210 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3215 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3221 .prepare = ad1984_pcm_dmic_prepare,
3222 .cleanup = ad1984_pcm_dmic_cleanup
3226 static int ad1984_build_pcms(struct hda_codec *codec)
3228 struct ad198x_spec *spec = codec->spec;
3229 struct hda_pcm *info;
3232 err = ad198x_build_pcms(codec);
3236 info = spec->pcm_rec + codec->num_pcms;
3238 info->name = "AD1984 Digital Mic";
3239 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3250 static const char *ad1984_models[AD1984_MODELS] = {
3251 [AD1984_BASIC] = "basic",
3252 [AD1984_THINKPAD] = "thinkpad",
3255 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3256 /* Lenovo Thinkpad T61/X61 */
3257 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1984_THINKPAD),
3261 static int patch_ad1984(struct hda_codec *codec)
3263 struct ad198x_spec *spec;
3264 int board_config, err;
3266 err = patch_ad1884(codec);
3270 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3271 ad1984_models, ad1984_cfg_tbl);
3272 switch (board_config) {
3274 /* additional digital mics */
3275 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3276 codec->patch_ops.build_pcms = ad1984_build_pcms;
3278 case AD1984_THINKPAD:
3279 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3280 spec->input_mux = &ad1984_thinkpad_capture_source;
3281 spec->mixers[0] = ad1984_thinkpad_mixers;
3282 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3292 * port-A - front hp-out
3293 * port-B - front mic-in
3294 * port-C - rear line-in, shared surr-out (3stack)
3295 * port-D - rear line-out
3296 * port-E - rear mic-in, shared clfe-out (3stack)
3297 * port-F - rear surr-out (6stack)
3298 * port-G - rear clfe-out (6stack)
3301 static hda_nid_t ad1882_dac_nids[3] = {
3305 static hda_nid_t ad1882_adc_nids[2] = {
3309 static hda_nid_t ad1882_capsrc_nids[2] = {
3313 #define AD1882_SPDIF_OUT 0x02
3315 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
3316 static struct hda_input_mux ad1882_capture_source = {
3319 { "Front Mic", 0x1 },
3327 static struct snd_kcontrol_new ad1882_base_mixers[] = {
3328 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3329 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
3330 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
3331 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
3332 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3333 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3334 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3335 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3336 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3337 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3338 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3339 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3340 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
3341 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
3342 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
3343 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
3344 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
3345 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
3346 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
3347 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
3348 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
3349 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3350 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3351 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3352 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3354 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3355 /* The multiple "Capture Source" controls confuse alsamixer
3356 * So call somewhat different..
3358 /* .name = "Capture Source", */
3359 .name = "Input Source",
3361 .info = ad198x_mux_enum_info,
3362 .get = ad198x_mux_enum_get,
3363 .put = ad198x_mux_enum_put,
3365 /* SPDIF controls */
3366 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3368 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3369 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3370 /* identical with ad1983 */
3371 .info = ad1983_spdif_route_info,
3372 .get = ad1983_spdif_route_get,
3373 .put = ad1983_spdif_route_put,
3378 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
3379 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
3380 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
3381 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
3383 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3384 .name = "Channel Mode",
3385 .info = ad198x_ch_mode_info,
3386 .get = ad198x_ch_mode_get,
3387 .put = ad198x_ch_mode_put,
3392 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
3393 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
3394 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
3395 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
3399 static struct hda_verb ad1882_ch2_init[] = {
3400 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3401 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3402 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3403 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3404 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3405 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3409 static struct hda_verb ad1882_ch4_init[] = {
3410 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3411 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3412 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3413 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3414 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3415 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3419 static struct hda_verb ad1882_ch6_init[] = {
3420 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3421 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3422 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3423 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3424 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3425 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3429 static struct hda_channel_mode ad1882_modes[3] = {
3430 { 2, ad1882_ch2_init },
3431 { 4, ad1882_ch4_init },
3432 { 6, ad1882_ch6_init },
3436 * initialization verbs
3438 static struct hda_verb ad1882_init_verbs[] = {
3439 /* DACs; mute as default */
3440 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3441 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3442 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3443 /* Port-A (HP) mixer */
3444 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3445 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3447 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3448 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3449 /* HP selector - select DAC2 */
3450 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
3451 /* Port-D (Line-out) mixer */
3452 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3453 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3455 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3456 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3457 /* Mono-out mixer */
3458 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3459 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3461 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3462 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3463 /* Port-B (front mic) pin */
3464 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3465 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3466 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3467 /* Port-C (line-in) pin */
3468 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3469 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3470 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3471 /* Port-C mixer - mute as input */
3472 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3473 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3474 /* Port-E (mic-in) pin */
3475 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3476 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3477 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3478 /* Port-E mixer - mute as input */
3479 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3480 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3481 /* Port-F (surround) */
3482 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3483 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3485 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3486 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3487 /* Analog mixer; mute as default */
3488 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
3489 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3490 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3491 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3492 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3493 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3494 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3495 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3496 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3497 /* Analog Mix output amp */
3498 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3499 /* SPDIF output selector */
3500 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3501 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3502 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3506 #ifdef CONFIG_SND_HDA_POWER_SAVE
3507 static struct hda_amp_list ad1882_loopbacks[] = {
3508 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3509 { 0x20, HDA_INPUT, 1 }, /* Mic */
3510 { 0x20, HDA_INPUT, 4 }, /* Line */
3511 { 0x20, HDA_INPUT, 6 }, /* CD */
3523 static const char *ad1882_models[AD1986A_MODELS] = {
3524 [AD1882_3STACK] = "3stack",
3525 [AD1882_6STACK] = "6stack",
3529 static int patch_ad1882(struct hda_codec *codec)
3531 struct ad198x_spec *spec;
3534 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3538 mutex_init(&spec->amp_mutex);
3541 spec->multiout.max_channels = 6;
3542 spec->multiout.num_dacs = 3;
3543 spec->multiout.dac_nids = ad1882_dac_nids;
3544 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
3545 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
3546 spec->adc_nids = ad1882_adc_nids;
3547 spec->capsrc_nids = ad1882_capsrc_nids;
3548 spec->input_mux = &ad1882_capture_source;
3549 spec->num_mixers = 1;
3550 spec->mixers[0] = ad1882_base_mixers;
3551 spec->num_init_verbs = 1;
3552 spec->init_verbs[0] = ad1882_init_verbs;
3553 spec->spdif_route = 0;
3554 #ifdef CONFIG_SND_HDA_POWER_SAVE
3555 spec->loopback.amplist = ad1882_loopbacks;
3557 spec->vmaster_nid = 0x04;
3559 codec->patch_ops = ad198x_patch_ops;
3561 /* override some parameters */
3562 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
3563 ad1882_models, NULL);
3564 switch (board_config) {
3567 spec->num_mixers = 2;
3568 spec->mixers[1] = ad1882_3stack_mixers;
3569 spec->channel_mode = ad1882_modes;
3570 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
3571 spec->need_dac_fix = 1;
3572 spec->multiout.max_channels = 2;
3573 spec->multiout.num_dacs = 1;
3576 spec->num_mixers = 2;
3577 spec->mixers[1] = ad1882_6stack_mixers;
3587 struct hda_codec_preset snd_hda_preset_analog[] = {
3588 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
3589 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
3590 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
3591 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
3592 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
3593 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
3594 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
3595 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },