2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for ALC 260/880/882 codecs
6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7 * PeiSen Hou <pshou@realtek.com.tw>
8 * Takashi Iwai <tiwai@suse.de>
9 * Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
11 * This driver is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This driver is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <sound/core.h>
31 #include "hda_codec.h"
32 #include "hda_local.h"
35 #define ALC880_FRONT_EVENT 0x01
36 #define ALC880_DCVOL_EVENT 0x02
37 #define ALC880_HP_EVENT 0x04
38 #define ALC880_MIC_EVENT 0x08
40 /* ALC880 board config type */
64 #ifdef CONFIG_SND_DEBUG
68 ALC880_MODEL_LAST /* last tag */
82 #ifdef CONFIG_SND_DEBUG
86 ALC260_MODEL_LAST /* last tag */
96 ALC262_HP_BPC_D7000_WL,
97 ALC262_HP_BPC_D7000_WF,
110 ALC262_MODEL_LAST /* last tag */
120 ALC268_ACER_ASPIRE_ONE,
123 #ifdef CONFIG_SND_DEBUG
127 ALC268_MODEL_LAST /* last tag */
134 ALC269_ASUS_EEEPC_P703,
135 ALC269_ASUS_EEEPC_P901,
139 ALC269_MODEL_LAST /* last tag */
156 /* ALC861-VD models */
178 ALC662_ASUS_EEEPC_P701,
179 ALC662_ASUS_EEEPC_EP20,
218 ALC883_TARGA_2ch_DIG,
221 ALC888_ACER_ASPIRE_4930G,
225 ALC883_LENOVO_101E_2ch,
226 ALC883_LENOVO_NB0763,
227 ALC888_LENOVO_MS7195_DIG,
234 ALC883_FUJITSU_PI2515,
235 ALC888_FUJITSU_XA3530,
236 ALC883_3ST_6ch_INTEL,
244 /* styles of capture selection */
246 CAPT_MUX = 0, /* only mux based */
247 CAPT_MIX, /* only mixer based */
248 CAPT_1MUX_MIX, /* first mux and other mixers */
252 #define GPIO_MASK 0x03
255 /* codec parameterization */
256 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
257 unsigned int num_mixers;
258 struct snd_kcontrol_new *cap_mixer; /* capture mixer */
259 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
261 const struct hda_verb *init_verbs[5]; /* initialization verbs
265 unsigned int num_init_verbs;
267 char *stream_name_analog; /* analog PCM stream */
268 struct hda_pcm_stream *stream_analog_playback;
269 struct hda_pcm_stream *stream_analog_capture;
270 struct hda_pcm_stream *stream_analog_alt_playback;
271 struct hda_pcm_stream *stream_analog_alt_capture;
273 char *stream_name_digital; /* digital PCM stream */
274 struct hda_pcm_stream *stream_digital_playback;
275 struct hda_pcm_stream *stream_digital_capture;
278 struct hda_multi_out multiout; /* playback set-up
279 * max_channels, dacs must be set
280 * dig_out_nid and hp_nid are optional
282 hda_nid_t alt_dac_nid;
283 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */
287 unsigned int num_adc_nids;
289 hda_nid_t *capsrc_nids;
290 hda_nid_t dig_in_nid; /* digital-in NID; optional */
291 int capture_style; /* capture style (CAPT_*) */
294 unsigned int num_mux_defs;
295 const struct hda_input_mux *input_mux;
296 unsigned int cur_mux[3];
299 const struct hda_channel_mode *channel_mode;
300 int num_channel_mode;
303 /* PCM information */
304 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
306 /* dynamic controls, init_verbs and input_mux */
307 struct auto_pin_cfg autocfg;
308 struct snd_array kctls;
309 struct hda_input_mux private_imux[3];
310 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
313 void (*init_hook)(struct hda_codec *codec);
314 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
316 /* for pin sensing */
317 unsigned int sense_updated: 1;
318 unsigned int jack_present: 1;
319 unsigned int master_sw: 1;
322 unsigned int no_analog :1; /* digital I/O only */
324 /* for virtual master */
325 hda_nid_t vmaster_nid;
326 #ifdef CONFIG_SND_HDA_POWER_SAVE
327 struct hda_loopback_check loopback;
332 unsigned int pll_coef_idx, pll_coef_bit;
336 * configuration template - to be copied to the spec instance
338 struct alc_config_preset {
339 struct snd_kcontrol_new *mixers[5]; /* should be identical size
342 struct snd_kcontrol_new *cap_mixer; /* capture mixer */
343 const struct hda_verb *init_verbs[5];
344 unsigned int num_dacs;
346 hda_nid_t dig_out_nid; /* optional */
347 hda_nid_t hp_nid; /* optional */
348 hda_nid_t *slave_dig_outs;
349 unsigned int num_adc_nids;
351 hda_nid_t *capsrc_nids;
352 hda_nid_t dig_in_nid;
353 unsigned int num_channel_mode;
354 const struct hda_channel_mode *channel_mode;
356 unsigned int num_mux_defs;
357 const struct hda_input_mux *input_mux;
358 void (*unsol_event)(struct hda_codec *, unsigned int);
359 void (*init_hook)(struct hda_codec *);
360 #ifdef CONFIG_SND_HDA_POWER_SAVE
361 struct hda_amp_list *loopbacks;
369 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
370 struct snd_ctl_elem_info *uinfo)
372 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
373 struct alc_spec *spec = codec->spec;
374 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
375 if (mux_idx >= spec->num_mux_defs)
377 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
380 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
381 struct snd_ctl_elem_value *ucontrol)
383 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
384 struct alc_spec *spec = codec->spec;
385 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
387 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
391 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
392 struct snd_ctl_elem_value *ucontrol)
394 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
395 struct alc_spec *spec = codec->spec;
396 const struct hda_input_mux *imux;
397 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
398 unsigned int mux_idx;
399 hda_nid_t nid = spec->capsrc_nids ?
400 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
402 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
403 imux = &spec->input_mux[mux_idx];
405 if (spec->capture_style &&
406 !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
407 /* Matrix-mixer style (e.g. ALC882) */
408 unsigned int *cur_val = &spec->cur_mux[adc_idx];
411 idx = ucontrol->value.enumerated.item[0];
412 if (idx >= imux->num_items)
413 idx = imux->num_items - 1;
416 for (i = 0; i < imux->num_items; i++) {
417 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
418 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
419 imux->items[i].index,
425 /* MUX style (e.g. ALC880) */
426 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
427 &spec->cur_mux[adc_idx]);
432 * channel mode setting
434 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
435 struct snd_ctl_elem_info *uinfo)
437 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
438 struct alc_spec *spec = codec->spec;
439 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
440 spec->num_channel_mode);
443 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
444 struct snd_ctl_elem_value *ucontrol)
446 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
447 struct alc_spec *spec = codec->spec;
448 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
449 spec->num_channel_mode,
450 spec->multiout.max_channels);
453 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
454 struct snd_ctl_elem_value *ucontrol)
456 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
457 struct alc_spec *spec = codec->spec;
458 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
459 spec->num_channel_mode,
460 &spec->multiout.max_channels);
461 if (err >= 0 && spec->need_dac_fix)
462 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
467 * Control the mode of pin widget settings via the mixer. "pc" is used
468 * instead of "%" to avoid consequences of accidently treating the % as
469 * being part of a format specifier. Maximum allowed length of a value is
470 * 63 characters plus NULL terminator.
472 * Note: some retasking pin complexes seem to ignore requests for input
473 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
474 * are requested. Therefore order this list so that this behaviour will not
475 * cause problems when mixer clients move through the enum sequentially.
476 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
479 static char *alc_pin_mode_names[] = {
480 "Mic 50pc bias", "Mic 80pc bias",
481 "Line in", "Line out", "Headphone out",
483 static unsigned char alc_pin_mode_values[] = {
484 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
486 /* The control can present all 5 options, or it can limit the options based
487 * in the pin being assumed to be exclusively an input or an output pin. In
488 * addition, "input" pins may or may not process the mic bias option
489 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
490 * accept requests for bias as of chip versions up to March 2006) and/or
491 * wiring in the computer.
493 #define ALC_PIN_DIR_IN 0x00
494 #define ALC_PIN_DIR_OUT 0x01
495 #define ALC_PIN_DIR_INOUT 0x02
496 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03
497 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
499 /* Info about the pin modes supported by the different pin direction modes.
500 * For each direction the minimum and maximum values are given.
502 static signed char alc_pin_mode_dir_info[5][2] = {
503 { 0, 2 }, /* ALC_PIN_DIR_IN */
504 { 3, 4 }, /* ALC_PIN_DIR_OUT */
505 { 0, 4 }, /* ALC_PIN_DIR_INOUT */
506 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
507 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
509 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
510 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
511 #define alc_pin_mode_n_items(_dir) \
512 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
514 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
515 struct snd_ctl_elem_info *uinfo)
517 unsigned int item_num = uinfo->value.enumerated.item;
518 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
520 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
522 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
524 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
525 item_num = alc_pin_mode_min(dir);
526 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
530 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
531 struct snd_ctl_elem_value *ucontrol)
534 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
535 hda_nid_t nid = kcontrol->private_value & 0xffff;
536 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
537 long *valp = ucontrol->value.integer.value;
538 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
539 AC_VERB_GET_PIN_WIDGET_CONTROL,
542 /* Find enumerated value for current pinctl setting */
543 i = alc_pin_mode_min(dir);
544 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
546 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
550 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
551 struct snd_ctl_elem_value *ucontrol)
554 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
555 hda_nid_t nid = kcontrol->private_value & 0xffff;
556 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
557 long val = *ucontrol->value.integer.value;
558 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
559 AC_VERB_GET_PIN_WIDGET_CONTROL,
562 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
563 val = alc_pin_mode_min(dir);
565 change = pinctl != alc_pin_mode_values[val];
567 /* Set pin mode to that requested */
568 snd_hda_codec_write_cache(codec, nid, 0,
569 AC_VERB_SET_PIN_WIDGET_CONTROL,
570 alc_pin_mode_values[val]);
572 /* Also enable the retasking pin's input/output as required
573 * for the requested pin mode. Enum values of 2 or less are
576 * Dynamically switching the input/output buffers probably
577 * reduces noise slightly (particularly on input) so we'll
578 * do it. However, having both input and output buffers
579 * enabled simultaneously doesn't seem to be problematic if
580 * this turns out to be necessary in the future.
583 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
584 HDA_AMP_MUTE, HDA_AMP_MUTE);
585 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
588 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
589 HDA_AMP_MUTE, HDA_AMP_MUTE);
590 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
597 #define ALC_PIN_MODE(xname, nid, dir) \
598 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
599 .info = alc_pin_mode_info, \
600 .get = alc_pin_mode_get, \
601 .put = alc_pin_mode_put, \
602 .private_value = nid | (dir<<16) }
604 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
605 * together using a mask with more than one bit set. This control is
606 * currently used only by the ALC260 test model. At this stage they are not
607 * needed for any "production" models.
609 #ifdef CONFIG_SND_DEBUG
610 #define alc_gpio_data_info snd_ctl_boolean_mono_info
612 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
613 struct snd_ctl_elem_value *ucontrol)
615 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
616 hda_nid_t nid = kcontrol->private_value & 0xffff;
617 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
618 long *valp = ucontrol->value.integer.value;
619 unsigned int val = snd_hda_codec_read(codec, nid, 0,
620 AC_VERB_GET_GPIO_DATA, 0x00);
622 *valp = (val & mask) != 0;
625 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
626 struct snd_ctl_elem_value *ucontrol)
629 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
630 hda_nid_t nid = kcontrol->private_value & 0xffff;
631 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
632 long val = *ucontrol->value.integer.value;
633 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
634 AC_VERB_GET_GPIO_DATA,
637 /* Set/unset the masked GPIO bit(s) as needed */
638 change = (val == 0 ? 0 : mask) != (gpio_data & mask);
643 snd_hda_codec_write_cache(codec, nid, 0,
644 AC_VERB_SET_GPIO_DATA, gpio_data);
648 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
649 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
650 .info = alc_gpio_data_info, \
651 .get = alc_gpio_data_get, \
652 .put = alc_gpio_data_put, \
653 .private_value = nid | (mask<<16) }
654 #endif /* CONFIG_SND_DEBUG */
656 /* A switch control to allow the enabling of the digital IO pins on the
657 * ALC260. This is incredibly simplistic; the intention of this control is
658 * to provide something in the test model allowing digital outputs to be
659 * identified if present. If models are found which can utilise these
660 * outputs a more complete mixer control can be devised for those models if
663 #ifdef CONFIG_SND_DEBUG
664 #define alc_spdif_ctrl_info snd_ctl_boolean_mono_info
666 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
667 struct snd_ctl_elem_value *ucontrol)
669 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
670 hda_nid_t nid = kcontrol->private_value & 0xffff;
671 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
672 long *valp = ucontrol->value.integer.value;
673 unsigned int val = snd_hda_codec_read(codec, nid, 0,
674 AC_VERB_GET_DIGI_CONVERT_1, 0x00);
676 *valp = (val & mask) != 0;
679 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
680 struct snd_ctl_elem_value *ucontrol)
683 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
684 hda_nid_t nid = kcontrol->private_value & 0xffff;
685 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
686 long val = *ucontrol->value.integer.value;
687 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
688 AC_VERB_GET_DIGI_CONVERT_1,
691 /* Set/unset the masked control bit(s) as needed */
692 change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
697 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
702 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
703 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
704 .info = alc_spdif_ctrl_info, \
705 .get = alc_spdif_ctrl_get, \
706 .put = alc_spdif_ctrl_put, \
707 .private_value = nid | (mask<<16) }
708 #endif /* CONFIG_SND_DEBUG */
710 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
711 * Again, this is only used in the ALC26x test models to help identify when
712 * the EAPD line must be asserted for features to work.
714 #ifdef CONFIG_SND_DEBUG
715 #define alc_eapd_ctrl_info snd_ctl_boolean_mono_info
717 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
718 struct snd_ctl_elem_value *ucontrol)
720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
721 hda_nid_t nid = kcontrol->private_value & 0xffff;
722 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
723 long *valp = ucontrol->value.integer.value;
724 unsigned int val = snd_hda_codec_read(codec, nid, 0,
725 AC_VERB_GET_EAPD_BTLENABLE, 0x00);
727 *valp = (val & mask) != 0;
731 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
732 struct snd_ctl_elem_value *ucontrol)
735 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
736 hda_nid_t nid = kcontrol->private_value & 0xffff;
737 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
738 long val = *ucontrol->value.integer.value;
739 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
740 AC_VERB_GET_EAPD_BTLENABLE,
743 /* Set/unset the masked control bit(s) as needed */
744 change = (!val ? 0 : mask) != (ctrl_data & mask);
749 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
755 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
756 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
757 .info = alc_eapd_ctrl_info, \
758 .get = alc_eapd_ctrl_get, \
759 .put = alc_eapd_ctrl_put, \
760 .private_value = nid | (mask<<16) }
761 #endif /* CONFIG_SND_DEBUG */
764 * set up the input pin config (depending on the given auto-pin type)
766 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
769 unsigned int val = PIN_IN;
771 if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
773 pincap = snd_hda_query_pin_caps(codec, nid);
774 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
775 if (pincap & AC_PINCAP_VREF_80)
778 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
783 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
785 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
787 spec->mixers[spec->num_mixers++] = mix;
790 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
792 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
794 spec->init_verbs[spec->num_init_verbs++] = verb;
797 #ifdef CONFIG_PROC_FS
801 static void print_realtek_coef(struct snd_info_buffer *buffer,
802 struct hda_codec *codec, hda_nid_t nid)
808 coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
809 snd_iprintf(buffer, " Processing Coefficient: 0x%02x\n", coeff);
810 coeff = snd_hda_codec_read(codec, nid, 0,
811 AC_VERB_GET_COEF_INDEX, 0);
812 snd_iprintf(buffer, " Coefficient Index: 0x%02x\n", coeff);
815 #define print_realtek_coef NULL
819 * set up from the preset table
821 static void setup_preset(struct alc_spec *spec,
822 const struct alc_config_preset *preset)
826 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
827 add_mixer(spec, preset->mixers[i]);
828 spec->cap_mixer = preset->cap_mixer;
829 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
831 add_verb(spec, preset->init_verbs[i]);
833 spec->channel_mode = preset->channel_mode;
834 spec->num_channel_mode = preset->num_channel_mode;
835 spec->need_dac_fix = preset->need_dac_fix;
837 spec->multiout.max_channels = spec->channel_mode[0].channels;
839 spec->multiout.num_dacs = preset->num_dacs;
840 spec->multiout.dac_nids = preset->dac_nids;
841 spec->multiout.dig_out_nid = preset->dig_out_nid;
842 spec->multiout.slave_dig_outs = preset->slave_dig_outs;
843 spec->multiout.hp_nid = preset->hp_nid;
845 spec->num_mux_defs = preset->num_mux_defs;
846 if (!spec->num_mux_defs)
847 spec->num_mux_defs = 1;
848 spec->input_mux = preset->input_mux;
850 spec->num_adc_nids = preset->num_adc_nids;
851 spec->adc_nids = preset->adc_nids;
852 spec->capsrc_nids = preset->capsrc_nids;
853 spec->dig_in_nid = preset->dig_in_nid;
855 spec->unsol_event = preset->unsol_event;
856 spec->init_hook = preset->init_hook;
857 #ifdef CONFIG_SND_HDA_POWER_SAVE
858 spec->loopback.amplist = preset->loopbacks;
862 /* Enable GPIO mask and set output */
863 static struct hda_verb alc_gpio1_init_verbs[] = {
864 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
865 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
866 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
870 static struct hda_verb alc_gpio2_init_verbs[] = {
871 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
872 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
873 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
877 static struct hda_verb alc_gpio3_init_verbs[] = {
878 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
879 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
880 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
885 * Fix hardware PLL issue
886 * On some codecs, the analog PLL gating control must be off while
887 * the default value is 1.
889 static void alc_fix_pll(struct hda_codec *codec)
891 struct alc_spec *spec = codec->spec;
896 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
898 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
899 AC_VERB_GET_PROC_COEF, 0);
900 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
902 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
903 val & ~(1 << spec->pll_coef_bit));
906 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
907 unsigned int coef_idx, unsigned int coef_bit)
909 struct alc_spec *spec = codec->spec;
911 spec->pll_coef_idx = coef_idx;
912 spec->pll_coef_bit = coef_bit;
916 static void alc_sku_automute(struct hda_codec *codec)
918 struct alc_spec *spec = codec->spec;
919 unsigned int present;
920 unsigned int hp_nid = spec->autocfg.hp_pins[0];
921 unsigned int sp_nid = spec->autocfg.speaker_pins[0];
923 /* need to execute and sync at first */
924 snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
925 present = snd_hda_codec_read(codec, hp_nid, 0,
926 AC_VERB_GET_PIN_SENSE, 0);
927 spec->jack_present = (present & 0x80000000) != 0;
928 snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
929 spec->jack_present ? 0 : PIN_OUT);
932 #if 0 /* it's broken in some acses -- temporarily disabled */
933 static void alc_mic_automute(struct hda_codec *codec)
935 struct alc_spec *spec = codec->spec;
936 unsigned int present;
937 unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
938 unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
939 unsigned int mix_nid = spec->capsrc_nids[0];
940 unsigned int capsrc_idx_mic, capsrc_idx_fmic;
942 capsrc_idx_mic = mic_nid - 0x18;
943 capsrc_idx_fmic = fmic_nid - 0x18;
944 present = snd_hda_codec_read(codec, mic_nid, 0,
945 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
946 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
947 0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
948 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
949 0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
950 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
951 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
954 #define alc_mic_automute(codec) do {} while(0) /* NOP */
955 #endif /* disabled */
957 /* unsolicited event for HP jack sensing */
958 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
960 if (codec->vendor_id == 0x10ec0880)
964 if (res == ALC880_HP_EVENT)
965 alc_sku_automute(codec);
967 if (res == ALC880_MIC_EVENT)
968 alc_mic_automute(codec);
971 static void alc_inithook(struct hda_codec *codec)
973 alc_sku_automute(codec);
974 alc_mic_automute(codec);
977 /* additional initialization for ALC888 variants */
978 static void alc888_coef_init(struct hda_codec *codec)
982 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
983 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
984 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
985 if ((tmp & 0xf0) == 0x20)
987 snd_hda_codec_read(codec, 0x20, 0,
988 AC_VERB_SET_PROC_COEF, 0x830);
991 snd_hda_codec_read(codec, 0x20, 0,
992 AC_VERB_SET_PROC_COEF, 0x3030);
995 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
996 * 31 ~ 16 : Manufacture ID
998 * 7 ~ 0 : Assembly ID
999 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1001 static void alc_subsystem_id(struct hda_codec *codec,
1002 unsigned int porta, unsigned int porte,
1005 unsigned int ass, tmp, i;
1007 struct alc_spec *spec = codec->spec;
1009 ass = codec->subsystem_id & 0xffff;
1010 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1014 * 31~30 : port conetcivity
1017 * 19~16 : Check sum (15:1)
1022 if (codec->vendor_id == 0x10ec0260)
1024 ass = snd_hda_codec_get_pincfg(codec, nid);
1025 if (!(ass & 1) && !(ass & 0x100000))
1027 if ((ass >> 30) != 1) /* no physical connection */
1032 for (i = 1; i < 16; i++) {
1036 if (((ass >> 16) & 0xf) != tmp)
1042 * 2 : 0 --> Desktop, 1 --> Laptop
1043 * 3~5 : External Amplifier control
1046 tmp = (ass & 0x38) >> 3; /* external Amp control */
1049 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1052 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1055 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1057 case 5: /* set EAPD output high */
1058 switch (codec->vendor_id) {
1060 snd_hda_codec_write(codec, 0x0f, 0,
1061 AC_VERB_SET_EAPD_BTLENABLE, 2);
1062 snd_hda_codec_write(codec, 0x10, 0,
1063 AC_VERB_SET_EAPD_BTLENABLE, 2);
1075 snd_hda_codec_write(codec, 0x14, 0,
1076 AC_VERB_SET_EAPD_BTLENABLE, 2);
1077 snd_hda_codec_write(codec, 0x15, 0,
1078 AC_VERB_SET_EAPD_BTLENABLE, 2);
1081 switch (codec->vendor_id) {
1083 snd_hda_codec_write(codec, 0x1a, 0,
1084 AC_VERB_SET_COEF_INDEX, 7);
1085 tmp = snd_hda_codec_read(codec, 0x1a, 0,
1086 AC_VERB_GET_PROC_COEF, 0);
1087 snd_hda_codec_write(codec, 0x1a, 0,
1088 AC_VERB_SET_COEF_INDEX, 7);
1089 snd_hda_codec_write(codec, 0x1a, 0,
1090 AC_VERB_SET_PROC_COEF,
1100 snd_hda_codec_write(codec, 0x20, 0,
1101 AC_VERB_SET_COEF_INDEX, 7);
1102 tmp = snd_hda_codec_read(codec, 0x20, 0,
1103 AC_VERB_GET_PROC_COEF, 0);
1104 snd_hda_codec_write(codec, 0x20, 0,
1105 AC_VERB_SET_COEF_INDEX, 7);
1106 snd_hda_codec_write(codec, 0x20, 0,
1107 AC_VERB_SET_PROC_COEF,
1111 /*alc888_coef_init(codec);*/ /* called in alc_init() */
1115 snd_hda_codec_write(codec, 0x20, 0,
1116 AC_VERB_SET_COEF_INDEX, 7);
1117 tmp = snd_hda_codec_read(codec, 0x20, 0,
1118 AC_VERB_GET_PROC_COEF, 0);
1119 snd_hda_codec_write(codec, 0x20, 0,
1120 AC_VERB_SET_COEF_INDEX, 7);
1121 snd_hda_codec_write(codec, 0x20, 0,
1122 AC_VERB_SET_PROC_COEF,
1130 /* is laptop or Desktop and enable the function "Mute internal speaker
1131 * when the external headphone out jack is plugged"
1133 if (!(ass & 0x8000))
1136 * 10~8 : Jack location
1137 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1139 * 15 : 1 --> enable the function "Mute internal speaker
1140 * when the external headphone out jack is plugged"
1142 if (!spec->autocfg.speaker_pins[0]) {
1143 if (spec->autocfg.line_out_pins[0])
1144 spec->autocfg.speaker_pins[0] =
1145 spec->autocfg.line_out_pins[0];
1150 if (!spec->autocfg.hp_pins[0]) {
1151 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1153 spec->autocfg.hp_pins[0] = porta;
1155 spec->autocfg.hp_pins[0] = porte;
1157 spec->autocfg.hp_pins[0] = portd;
1161 if (spec->autocfg.hp_pins[0])
1162 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1163 AC_VERB_SET_UNSOLICITED_ENABLE,
1164 AC_USRSP_EN | ALC880_HP_EVENT);
1166 #if 0 /* it's broken in some acses -- temporarily disabled */
1167 if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1168 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1169 snd_hda_codec_write(codec,
1170 spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1171 AC_VERB_SET_UNSOLICITED_ENABLE,
1172 AC_USRSP_EN | ALC880_MIC_EVENT);
1173 #endif /* disabled */
1175 spec->unsol_event = alc_sku_unsol_event;
1179 * Fix-up pin default configurations
1187 static void alc_fix_pincfg(struct hda_codec *codec,
1188 const struct snd_pci_quirk *quirk,
1189 const struct alc_pincfg **pinfix)
1191 const struct alc_pincfg *cfg;
1193 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1197 cfg = pinfix[quirk->value];
1198 for (; cfg->nid; cfg++)
1199 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1209 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1210 /* Mic-in jack as mic in */
1211 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1212 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1213 /* Line-in jack as Line in */
1214 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1215 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1216 /* Line-Out as Front */
1217 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1224 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1225 /* Mic-in jack as mic in */
1226 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1227 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1228 /* Line-in jack as Surround */
1229 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1230 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1231 /* Line-Out as Front */
1232 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1239 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1240 /* Mic-in jack as CLFE */
1241 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1242 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1243 /* Line-in jack as Surround */
1244 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1245 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1246 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1247 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1254 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1255 /* Mic-in jack as CLFE */
1256 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1257 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1258 /* Line-in jack as Surround */
1259 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1260 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1261 /* Line-Out as Side */
1262 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1266 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1267 { 2, alc888_4ST_ch2_intel_init },
1268 { 4, alc888_4ST_ch4_intel_init },
1269 { 6, alc888_4ST_ch6_intel_init },
1270 { 8, alc888_4ST_ch8_intel_init },
1274 * ALC888 Fujitsu Siemens Amillo xa3530
1277 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1278 /* Front Mic: set to PIN_IN (empty by default) */
1279 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1280 /* Connect Internal HP to Front */
1281 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1282 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1283 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1284 /* Connect Bass HP to Front */
1285 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1286 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1287 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1288 /* Connect Line-Out side jack (SPDIF) to Side */
1289 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1290 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1291 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1292 /* Connect Mic jack to CLFE */
1293 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1294 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1295 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1296 /* Connect Line-in jack to Surround */
1297 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1298 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1299 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1300 /* Connect HP out jack to Front */
1301 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1302 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1303 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1304 /* Enable unsolicited event for HP jack and Line-out jack */
1305 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1306 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1310 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1312 unsigned int present;
1314 /* Line out presence */
1315 present = snd_hda_codec_read(codec, 0x17, 0,
1316 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1317 /* HP out presence */
1318 present = present || snd_hda_codec_read(codec, 0x1b, 0,
1319 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1320 bits = present ? HDA_AMP_MUTE : 0;
1321 /* Toggle internal speakers muting */
1322 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1323 HDA_AMP_MUTE, bits);
1324 /* Toggle internal bass muting */
1325 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1326 HDA_AMP_MUTE, bits);
1329 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1332 if (res >> 26 == ALC880_HP_EVENT)
1333 alc888_fujitsu_xa3530_automute(codec);
1338 * ALC888 Acer Aspire 4930G model
1341 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1342 /* Front Mic: set to PIN_IN (empty by default) */
1343 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1344 /* Unselect Front Mic by default in input mixer 3 */
1345 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1346 /* Enable unsolicited event for HP jack */
1347 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1348 /* Connect Internal HP to front */
1349 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1350 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1351 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1352 /* Connect HP out to front */
1353 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1354 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1355 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1359 static struct hda_input_mux alc888_2_capture_sources[2] = {
1360 /* Front mic only available on one ADC */
1367 { "Front Mic", 0xb },
1380 static struct snd_kcontrol_new alc888_base_mixer[] = {
1381 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1382 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1383 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1384 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1385 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1387 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1388 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1389 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1390 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1391 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1392 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1393 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1394 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1395 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1396 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1397 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1398 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1402 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1404 unsigned int present;
1406 present = snd_hda_codec_read(codec, 0x15, 0,
1407 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1408 bits = present ? HDA_AMP_MUTE : 0;
1409 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1410 HDA_AMP_MUTE, bits);
1413 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1416 if (res >> 26 == ALC880_HP_EVENT)
1417 alc888_acer_aspire_4930g_automute(codec);
1421 * ALC880 3-stack model
1423 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1424 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1425 * F-Mic = 0x1b, HP = 0x19
1428 static hda_nid_t alc880_dac_nids[4] = {
1429 /* front, rear, clfe, rear_surr */
1430 0x02, 0x05, 0x04, 0x03
1433 static hda_nid_t alc880_adc_nids[3] = {
1438 /* The datasheet says the node 0x07 is connected from inputs,
1439 * but it shows zero connection in the real implementation on some devices.
1440 * Note: this is a 915GAV bug, fixed on 915GLV
1442 static hda_nid_t alc880_adc_nids_alt[2] = {
1447 #define ALC880_DIGOUT_NID 0x06
1448 #define ALC880_DIGIN_NID 0x0a
1450 static struct hda_input_mux alc880_capture_source = {
1454 { "Front Mic", 0x3 },
1460 /* channel source setting (2/6 channel selection for 3-stack) */
1462 static struct hda_verb alc880_threestack_ch2_init[] = {
1463 /* set line-in to input, mute it */
1464 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1465 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1466 /* set mic-in to input vref 80%, mute it */
1467 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1468 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1473 static struct hda_verb alc880_threestack_ch6_init[] = {
1474 /* set line-in to output, unmute it */
1475 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1476 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1477 /* set mic-in to output, unmute it */
1478 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1479 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1483 static struct hda_channel_mode alc880_threestack_modes[2] = {
1484 { 2, alc880_threestack_ch2_init },
1485 { 6, alc880_threestack_ch6_init },
1488 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1489 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1490 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1491 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1492 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1493 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1494 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1495 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1496 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1497 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1498 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1499 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1500 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1501 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1502 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1503 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1504 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1505 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1507 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1508 .name = "Channel Mode",
1509 .info = alc_ch_mode_info,
1510 .get = alc_ch_mode_get,
1511 .put = alc_ch_mode_put,
1516 /* capture mixer elements */
1517 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1518 struct snd_ctl_elem_info *uinfo)
1520 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1521 struct alc_spec *spec = codec->spec;
1524 mutex_lock(&codec->control_mutex);
1525 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1527 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1528 mutex_unlock(&codec->control_mutex);
1532 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1533 unsigned int size, unsigned int __user *tlv)
1535 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1536 struct alc_spec *spec = codec->spec;
1539 mutex_lock(&codec->control_mutex);
1540 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1542 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1543 mutex_unlock(&codec->control_mutex);
1547 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1548 struct snd_ctl_elem_value *ucontrol);
1550 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1551 struct snd_ctl_elem_value *ucontrol,
1554 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1555 struct alc_spec *spec = codec->spec;
1556 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1559 mutex_lock(&codec->control_mutex);
1560 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1562 err = func(kcontrol, ucontrol);
1563 mutex_unlock(&codec->control_mutex);
1567 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1568 struct snd_ctl_elem_value *ucontrol)
1570 return alc_cap_getput_caller(kcontrol, ucontrol,
1571 snd_hda_mixer_amp_volume_get);
1574 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1575 struct snd_ctl_elem_value *ucontrol)
1577 return alc_cap_getput_caller(kcontrol, ucontrol,
1578 snd_hda_mixer_amp_volume_put);
1581 /* capture mixer elements */
1582 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1584 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1585 struct snd_ctl_elem_value *ucontrol)
1587 return alc_cap_getput_caller(kcontrol, ucontrol,
1588 snd_hda_mixer_amp_switch_get);
1591 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1592 struct snd_ctl_elem_value *ucontrol)
1594 return alc_cap_getput_caller(kcontrol, ucontrol,
1595 snd_hda_mixer_amp_switch_put);
1598 #define _DEFINE_CAPMIX(num) \
1600 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1601 .name = "Capture Switch", \
1602 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1604 .info = alc_cap_sw_info, \
1605 .get = alc_cap_sw_get, \
1606 .put = alc_cap_sw_put, \
1609 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1610 .name = "Capture Volume", \
1611 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1612 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1613 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1615 .info = alc_cap_vol_info, \
1616 .get = alc_cap_vol_get, \
1617 .put = alc_cap_vol_put, \
1618 .tlv = { .c = alc_cap_vol_tlv }, \
1621 #define _DEFINE_CAPSRC(num) \
1623 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1624 /* .name = "Capture Source", */ \
1625 .name = "Input Source", \
1627 .info = alc_mux_enum_info, \
1628 .get = alc_mux_enum_get, \
1629 .put = alc_mux_enum_put, \
1632 #define DEFINE_CAPMIX(num) \
1633 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1634 _DEFINE_CAPMIX(num), \
1635 _DEFINE_CAPSRC(num), \
1639 #define DEFINE_CAPMIX_NOSRC(num) \
1640 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1641 _DEFINE_CAPMIX(num), \
1645 /* up to three ADCs */
1649 DEFINE_CAPMIX_NOSRC(1);
1650 DEFINE_CAPMIX_NOSRC(2);
1651 DEFINE_CAPMIX_NOSRC(3);
1654 * ALC880 5-stack model
1656 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1658 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1659 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1662 /* additional mixers to alc880_three_stack_mixer */
1663 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1664 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1665 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1669 /* channel source setting (6/8 channel selection for 5-stack) */
1671 static struct hda_verb alc880_fivestack_ch6_init[] = {
1672 /* set line-in to input, mute it */
1673 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1674 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1679 static struct hda_verb alc880_fivestack_ch8_init[] = {
1680 /* set line-in to output, unmute it */
1681 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1682 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1686 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1687 { 6, alc880_fivestack_ch6_init },
1688 { 8, alc880_fivestack_ch8_init },
1693 * ALC880 6-stack model
1695 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1696 * Side = 0x05 (0x0f)
1697 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1698 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1701 static hda_nid_t alc880_6st_dac_nids[4] = {
1702 /* front, rear, clfe, rear_surr */
1703 0x02, 0x03, 0x04, 0x05
1706 static struct hda_input_mux alc880_6stack_capture_source = {
1710 { "Front Mic", 0x1 },
1716 /* fixed 8-channels */
1717 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1721 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1722 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1723 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1724 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1725 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1726 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1727 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1728 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1729 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1730 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1731 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1732 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1733 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1734 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1735 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1736 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1737 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1738 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1739 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1741 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1742 .name = "Channel Mode",
1743 .info = alc_ch_mode_info,
1744 .get = alc_ch_mode_get,
1745 .put = alc_ch_mode_put,
1754 * W810 has rear IO for:
1757 * Center/LFE (DAC 04)
1760 * The system also has a pair of internal speakers, and a headphone jack.
1761 * These are both connected to Line2 on the codec, hence to DAC 02.
1763 * There is a variable resistor to control the speaker or headphone
1764 * volume. This is a hardware-only device without a software API.
1766 * Plugging headphones in will disable the internal speakers. This is
1767 * implemented in hardware, not via the driver using jack sense. In
1768 * a similar fashion, plugging into the rear socket marked "front" will
1769 * disable both the speakers and headphones.
1771 * For input, there's a microphone jack, and an "audio in" jack.
1772 * These may not do anything useful with this driver yet, because I
1773 * haven't setup any initialization verbs for these yet...
1776 static hda_nid_t alc880_w810_dac_nids[3] = {
1777 /* front, rear/surround, clfe */
1781 /* fixed 6 channels */
1782 static struct hda_channel_mode alc880_w810_modes[1] = {
1786 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1787 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1788 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1789 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1790 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1791 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1792 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1793 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1794 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1795 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1796 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1804 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1805 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1809 static hda_nid_t alc880_z71v_dac_nids[1] = {
1812 #define ALC880_Z71V_HP_DAC 0x03
1814 /* fixed 2 channels */
1815 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1819 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1820 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1821 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1822 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1823 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1824 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1825 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1826 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1827 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1833 * ALC880 F1734 model
1835 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1836 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1839 static hda_nid_t alc880_f1734_dac_nids[1] = {
1842 #define ALC880_F1734_HP_DAC 0x02
1844 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1845 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1846 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1847 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1848 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1849 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1850 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1851 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1852 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1856 static struct hda_input_mux alc880_f1734_capture_source = {
1868 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1869 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1870 * Mic = 0x18, Line = 0x1a
1873 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */
1874 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */
1876 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1877 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1878 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1879 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1880 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1881 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1882 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1883 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1884 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1885 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1886 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1887 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1888 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1889 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1890 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1892 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1893 .name = "Channel Mode",
1894 .info = alc_ch_mode_info,
1895 .get = alc_ch_mode_get,
1896 .put = alc_ch_mode_put,
1902 * ALC880 ASUS W1V model
1904 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1905 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1906 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1909 /* additional mixers to alc880_asus_mixer */
1910 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1911 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1912 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1917 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1918 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1919 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1920 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1921 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1922 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1923 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1924 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1925 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1926 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1931 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1932 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1933 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1934 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1935 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1936 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1937 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1938 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1939 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1940 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1941 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1942 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1943 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1944 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1945 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1946 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1947 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1949 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1950 .name = "Channel Mode",
1951 .info = alc_ch_mode_info,
1952 .get = alc_ch_mode_get,
1953 .put = alc_ch_mode_put,
1958 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1959 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1960 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1961 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1962 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1963 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1964 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1965 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1966 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1967 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1968 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1972 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1973 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1974 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1975 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1976 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1977 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1978 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1983 * virtual master controls
1987 * slave controls for virtual master
1989 static const char *alc_slave_vols[] = {
1990 "Front Playback Volume",
1991 "Surround Playback Volume",
1992 "Center Playback Volume",
1993 "LFE Playback Volume",
1994 "Side Playback Volume",
1995 "Headphone Playback Volume",
1996 "Speaker Playback Volume",
1997 "Mono Playback Volume",
1998 "Line-Out Playback Volume",
1999 "PCM Playback Volume",
2003 static const char *alc_slave_sws[] = {
2004 "Front Playback Switch",
2005 "Surround Playback Switch",
2006 "Center Playback Switch",
2007 "LFE Playback Switch",
2008 "Side Playback Switch",
2009 "Headphone Playback Switch",
2010 "Speaker Playback Switch",
2011 "Mono Playback Switch",
2012 "IEC958 Playback Switch",
2017 * build control elements
2020 static void alc_free_kctls(struct hda_codec *codec);
2022 /* additional beep mixers; the actual parameters are overwritten at build */
2023 static struct snd_kcontrol_new alc_beep_mixer[] = {
2024 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2025 HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2029 static int alc_build_controls(struct hda_codec *codec)
2031 struct alc_spec *spec = codec->spec;
2035 for (i = 0; i < spec->num_mixers; i++) {
2036 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2040 if (spec->cap_mixer) {
2041 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2045 if (spec->multiout.dig_out_nid) {
2046 err = snd_hda_create_spdif_out_ctls(codec,
2047 spec->multiout.dig_out_nid);
2050 if (!spec->no_analog) {
2051 err = snd_hda_create_spdif_share_sw(codec,
2055 spec->multiout.share_spdif = 1;
2058 if (spec->dig_in_nid) {
2059 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2064 /* create beep controls if needed */
2065 if (spec->beep_amp) {
2066 struct snd_kcontrol_new *knew;
2067 for (knew = alc_beep_mixer; knew->name; knew++) {
2068 struct snd_kcontrol *kctl;
2069 kctl = snd_ctl_new1(knew, codec);
2072 kctl->private_value = spec->beep_amp;
2073 err = snd_hda_ctl_add(codec, kctl);
2079 /* if we have no master control, let's create it */
2080 if (!spec->no_analog &&
2081 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2082 unsigned int vmaster_tlv[4];
2083 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2084 HDA_OUTPUT, vmaster_tlv);
2085 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2086 vmaster_tlv, alc_slave_vols);
2090 if (!spec->no_analog &&
2091 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2092 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2093 NULL, alc_slave_sws);
2098 alc_free_kctls(codec); /* no longer needed */
2104 * initialize the codec volumes, etc
2108 * generic initialization of ADC, input mixers and output mixers
2110 static struct hda_verb alc880_volume_init_verbs[] = {
2112 * Unmute ADC0-2 and set the default input to mic-in
2114 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2115 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2116 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2117 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2118 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2119 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2121 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2123 * Note: PASD motherboards uses the Line In 2 as the input for front
2126 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2127 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2128 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2129 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2130 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2131 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2132 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2133 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2136 * Set up output mixers (0x0c - 0x0f)
2138 /* set vol=0 to output mixers */
2139 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2140 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2141 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2142 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2143 /* set up input amps for analog loopback */
2144 /* Amp Indices: DAC = 0, mixer = 1 */
2145 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2146 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2147 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2148 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2149 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2150 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2151 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2152 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2158 * 3-stack pin configuration:
2159 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2161 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2163 * preset connection lists of input pins
2164 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2166 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2167 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2168 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2171 * Set pin mode and muting
2173 /* set front pin widgets 0x14 for output */
2174 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2175 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2176 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2177 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2178 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2179 /* Mic2 (as headphone out) for HP output */
2180 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2181 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2182 /* Line In pin widget for input */
2183 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2184 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2185 /* Line2 (as front mic) pin widget for input and vref at 80% */
2186 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2187 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2188 /* CD pin widget for input */
2189 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2195 * 5-stack pin configuration:
2196 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2197 * line-in/side = 0x1a, f-mic = 0x1b
2199 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2201 * preset connection lists of input pins
2202 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2204 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2205 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2208 * Set pin mode and muting
2210 /* set pin widgets 0x14-0x17 for output */
2211 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2212 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2213 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2214 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2215 /* unmute pins for output (no gain on this amp) */
2216 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2217 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2218 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2219 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2221 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2222 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2223 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2224 /* Mic2 (as headphone out) for HP output */
2225 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2226 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2227 /* Line In pin widget for input */
2228 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2229 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2230 /* Line2 (as front mic) pin widget for input and vref at 80% */
2231 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2232 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2233 /* CD pin widget for input */
2234 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2240 * W810 pin configuration:
2241 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2243 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2244 /* hphone/speaker input selector: front DAC */
2245 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2247 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2248 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2249 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2250 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2251 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2252 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2254 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2255 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2261 * Z71V pin configuration:
2262 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2264 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2265 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2266 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2267 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2268 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2270 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2271 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2272 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2273 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2279 * 6-stack pin configuration:
2280 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2281 * f-mic = 0x19, line = 0x1a, HP = 0x1b
2283 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2284 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2286 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2287 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2288 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2289 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2290 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2291 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2292 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2293 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2295 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2296 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2297 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2298 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2299 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2300 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2301 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2302 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2303 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2309 * Uniwill pin configuration:
2310 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2313 static struct hda_verb alc880_uniwill_init_verbs[] = {
2314 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2316 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2317 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2318 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2319 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2320 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2321 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2322 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2323 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2324 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2325 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2326 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2327 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2328 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2329 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2331 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2332 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2333 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2334 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2335 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2336 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2337 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2338 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2339 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2341 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2342 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2349 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2351 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2352 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2354 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2355 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2356 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2357 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2358 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2359 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2360 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2361 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2362 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2363 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2364 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2365 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2367 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2368 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2369 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2370 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2371 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2372 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2374 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2375 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2380 static struct hda_verb alc880_beep_init_verbs[] = {
2381 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2385 /* toggle speaker-output according to the hp-jack state */
2386 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2388 unsigned int present;
2391 present = snd_hda_codec_read(codec, 0x14, 0,
2392 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2393 bits = present ? HDA_AMP_MUTE : 0;
2394 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2395 HDA_AMP_MUTE, bits);
2396 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2397 HDA_AMP_MUTE, bits);
2400 /* auto-toggle front mic */
2401 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2403 unsigned int present;
2406 present = snd_hda_codec_read(codec, 0x18, 0,
2407 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2408 bits = present ? HDA_AMP_MUTE : 0;
2409 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2412 static void alc880_uniwill_automute(struct hda_codec *codec)
2414 alc880_uniwill_hp_automute(codec);
2415 alc880_uniwill_mic_automute(codec);
2418 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2421 /* Looks like the unsol event is incompatible with the standard
2422 * definition. 4bit tag is placed at 28 bit!
2424 switch (res >> 28) {
2425 case ALC880_HP_EVENT:
2426 alc880_uniwill_hp_automute(codec);
2428 case ALC880_MIC_EVENT:
2429 alc880_uniwill_mic_automute(codec);
2434 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2436 unsigned int present;
2439 present = snd_hda_codec_read(codec, 0x14, 0,
2440 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2441 bits = present ? HDA_AMP_MUTE : 0;
2442 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2445 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2447 unsigned int present;
2449 present = snd_hda_codec_read(codec, 0x21, 0,
2450 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2451 present &= HDA_AMP_VOLMASK;
2452 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2453 HDA_AMP_VOLMASK, present);
2454 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2455 HDA_AMP_VOLMASK, present);
2458 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2461 /* Looks like the unsol event is incompatible with the standard
2462 * definition. 4bit tag is placed at 28 bit!
2464 if ((res >> 28) == ALC880_HP_EVENT)
2465 alc880_uniwill_p53_hp_automute(codec);
2466 if ((res >> 28) == ALC880_DCVOL_EVENT)
2467 alc880_uniwill_p53_dcvol_automute(codec);
2471 * F1734 pin configuration:
2472 * HP = 0x14, speaker-out = 0x15, mic = 0x18
2474 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2475 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2476 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2477 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2478 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2479 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2481 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2482 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2483 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2484 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2486 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2487 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2488 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2489 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2490 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2491 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2492 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2493 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2494 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2496 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2497 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2503 * ASUS pin configuration:
2504 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2506 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2507 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2508 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2509 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2510 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2512 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2513 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2514 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2515 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2516 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2517 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2518 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2519 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2521 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2522 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2523 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2524 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2525 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2526 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2527 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2528 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2529 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2534 /* Enable GPIO mask and set output */
2535 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2536 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2538 /* Clevo m520g init */
2539 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2540 /* headphone output */
2541 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2543 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2544 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2546 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2547 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2549 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2550 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2551 /* Mic1 (rear panel) */
2552 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2553 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2554 /* Mic2 (front panel) */
2555 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2556 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2558 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2559 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2560 /* change to EAPD mode */
2561 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2562 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2567 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2568 /* change to EAPD mode */
2569 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2570 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2572 /* Headphone output */
2573 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2575 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2576 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2578 /* Line In pin widget for input */
2579 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2580 /* CD pin widget for input */
2581 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2582 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2583 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2585 /* change to EAPD mode */
2586 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2587 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
2593 * LG m1 express dual
2596 * Rear Line-In/Out (blue): 0x14
2597 * Build-in Mic-In: 0x15
2599 * HP-Out (green): 0x1b
2600 * Mic-In/Out (red): 0x19
2604 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2605 static hda_nid_t alc880_lg_dac_nids[3] = {
2609 /* seems analog CD is not working */
2610 static struct hda_input_mux alc880_lg_capture_source = {
2615 { "Internal Mic", 0x6 },
2619 /* 2,4,6 channel modes */
2620 static struct hda_verb alc880_lg_ch2_init[] = {
2621 /* set line-in and mic-in to input */
2622 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2623 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2627 static struct hda_verb alc880_lg_ch4_init[] = {
2628 /* set line-in to out and mic-in to input */
2629 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2630 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2634 static struct hda_verb alc880_lg_ch6_init[] = {
2635 /* set line-in and mic-in to output */
2636 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2637 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2641 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2642 { 2, alc880_lg_ch2_init },
2643 { 4, alc880_lg_ch4_init },
2644 { 6, alc880_lg_ch6_init },
2647 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2648 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2649 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2650 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2651 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2652 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2653 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2654 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2655 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2656 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2657 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2658 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2659 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2660 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2661 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2663 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2664 .name = "Channel Mode",
2665 .info = alc_ch_mode_info,
2666 .get = alc_ch_mode_get,
2667 .put = alc_ch_mode_put,
2672 static struct hda_verb alc880_lg_init_verbs[] = {
2673 /* set capture source to mic-in */
2674 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2675 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2676 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2677 /* mute all amp mixer inputs */
2678 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2679 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2680 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2681 /* line-in to input */
2682 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2683 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2685 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2686 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2688 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2689 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2690 /* mic-in to input */
2691 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2692 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2693 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2695 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2696 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2697 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2699 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2703 /* toggle speaker-output according to the hp-jack state */
2704 static void alc880_lg_automute(struct hda_codec *codec)
2706 unsigned int present;
2709 present = snd_hda_codec_read(codec, 0x1b, 0,
2710 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2711 bits = present ? HDA_AMP_MUTE : 0;
2712 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2713 HDA_AMP_MUTE, bits);
2716 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2718 /* Looks like the unsol event is incompatible with the standard
2719 * definition. 4bit tag is placed at 28 bit!
2721 if ((res >> 28) == 0x01)
2722 alc880_lg_automute(codec);
2731 * Built-in Mic-In: 0x19
2737 static struct hda_input_mux alc880_lg_lw_capture_source = {
2741 { "Internal Mic", 0x1 },
2746 #define alc880_lg_lw_modes alc880_threestack_modes
2748 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2749 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2750 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2751 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2752 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2753 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2754 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2755 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2756 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2757 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2758 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2759 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2760 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2761 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2762 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2764 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2765 .name = "Channel Mode",
2766 .info = alc_ch_mode_info,
2767 .get = alc_ch_mode_get,
2768 .put = alc_ch_mode_put,
2773 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2774 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2775 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2776 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2778 /* set capture source to mic-in */
2779 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2780 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2781 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2782 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2784 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2785 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2787 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2788 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2789 /* mic-in to input */
2790 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2791 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2793 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2794 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2796 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2800 /* toggle speaker-output according to the hp-jack state */
2801 static void alc880_lg_lw_automute(struct hda_codec *codec)
2803 unsigned int present;
2806 present = snd_hda_codec_read(codec, 0x1b, 0,
2807 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2808 bits = present ? HDA_AMP_MUTE : 0;
2809 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2810 HDA_AMP_MUTE, bits);
2813 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2815 /* Looks like the unsol event is incompatible with the standard
2816 * definition. 4bit tag is placed at 28 bit!
2818 if ((res >> 28) == 0x01)
2819 alc880_lg_lw_automute(codec);
2822 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2823 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2824 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2825 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2826 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2827 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2828 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2832 static struct hda_input_mux alc880_medion_rim_capture_source = {
2836 { "Internal Mic", 0x1 },
2840 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2841 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2843 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2844 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2846 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2847 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2848 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2849 /* Mic2 (as headphone out) for HP output */
2850 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2851 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2852 /* Internal Speaker */
2853 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2854 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2856 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2857 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2859 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2863 /* toggle speaker-output according to the hp-jack state */
2864 static void alc880_medion_rim_automute(struct hda_codec *codec)
2866 unsigned int present;
2869 present = snd_hda_codec_read(codec, 0x14, 0,
2870 AC_VERB_GET_PIN_SENSE, 0)
2871 & AC_PINSENSE_PRESENCE;
2872 bits = present ? HDA_AMP_MUTE : 0;
2873 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2874 HDA_AMP_MUTE, bits);
2876 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2878 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2881 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2884 /* Looks like the unsol event is incompatible with the standard
2885 * definition. 4bit tag is placed at 28 bit!
2887 if ((res >> 28) == ALC880_HP_EVENT)
2888 alc880_medion_rim_automute(codec);
2891 #ifdef CONFIG_SND_HDA_POWER_SAVE
2892 static struct hda_amp_list alc880_loopbacks[] = {
2893 { 0x0b, HDA_INPUT, 0 },
2894 { 0x0b, HDA_INPUT, 1 },
2895 { 0x0b, HDA_INPUT, 2 },
2896 { 0x0b, HDA_INPUT, 3 },
2897 { 0x0b, HDA_INPUT, 4 },
2901 static struct hda_amp_list alc880_lg_loopbacks[] = {
2902 { 0x0b, HDA_INPUT, 1 },
2903 { 0x0b, HDA_INPUT, 6 },
2904 { 0x0b, HDA_INPUT, 7 },
2913 static int alc_init(struct hda_codec *codec)
2915 struct alc_spec *spec = codec->spec;
2919 if (codec->vendor_id == 0x10ec0888)
2920 alc888_coef_init(codec);
2922 for (i = 0; i < spec->num_init_verbs; i++)
2923 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2925 if (spec->init_hook)
2926 spec->init_hook(codec);
2931 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2933 struct alc_spec *spec = codec->spec;
2935 if (spec->unsol_event)
2936 spec->unsol_event(codec, res);
2939 #ifdef CONFIG_SND_HDA_POWER_SAVE
2940 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2942 struct alc_spec *spec = codec->spec;
2943 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2948 * Analog playback callbacks
2950 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2951 struct hda_codec *codec,
2952 struct snd_pcm_substream *substream)
2954 struct alc_spec *spec = codec->spec;
2955 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2959 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2960 struct hda_codec *codec,
2961 unsigned int stream_tag,
2962 unsigned int format,
2963 struct snd_pcm_substream *substream)
2965 struct alc_spec *spec = codec->spec;
2966 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2967 stream_tag, format, substream);
2970 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2971 struct hda_codec *codec,
2972 struct snd_pcm_substream *substream)
2974 struct alc_spec *spec = codec->spec;
2975 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2981 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2982 struct hda_codec *codec,
2983 struct snd_pcm_substream *substream)
2985 struct alc_spec *spec = codec->spec;
2986 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2989 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2990 struct hda_codec *codec,
2991 unsigned int stream_tag,
2992 unsigned int format,
2993 struct snd_pcm_substream *substream)
2995 struct alc_spec *spec = codec->spec;
2996 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2997 stream_tag, format, substream);
3000 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3001 struct hda_codec *codec,
3002 struct snd_pcm_substream *substream)
3004 struct alc_spec *spec = codec->spec;
3005 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3008 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3009 struct hda_codec *codec,
3010 struct snd_pcm_substream *substream)
3012 struct alc_spec *spec = codec->spec;
3013 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3019 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3020 struct hda_codec *codec,
3021 unsigned int stream_tag,
3022 unsigned int format,
3023 struct snd_pcm_substream *substream)
3025 struct alc_spec *spec = codec->spec;
3027 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3028 stream_tag, 0, format);
3032 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3033 struct hda_codec *codec,
3034 struct snd_pcm_substream *substream)
3036 struct alc_spec *spec = codec->spec;
3038 snd_hda_codec_cleanup_stream(codec,
3039 spec->adc_nids[substream->number + 1]);
3046 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3050 /* NID is set in alc_build_pcms */
3052 .open = alc880_playback_pcm_open,
3053 .prepare = alc880_playback_pcm_prepare,
3054 .cleanup = alc880_playback_pcm_cleanup
3058 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3062 /* NID is set in alc_build_pcms */
3065 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3069 /* NID is set in alc_build_pcms */
3072 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3073 .substreams = 2, /* can be overridden */
3076 /* NID is set in alc_build_pcms */
3078 .prepare = alc880_alt_capture_pcm_prepare,
3079 .cleanup = alc880_alt_capture_pcm_cleanup
3083 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3087 /* NID is set in alc_build_pcms */
3089 .open = alc880_dig_playback_pcm_open,
3090 .close = alc880_dig_playback_pcm_close,
3091 .prepare = alc880_dig_playback_pcm_prepare,
3092 .cleanup = alc880_dig_playback_pcm_cleanup
3096 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3100 /* NID is set in alc_build_pcms */
3103 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3104 static struct hda_pcm_stream alc_pcm_null_stream = {
3110 static int alc_build_pcms(struct hda_codec *codec)
3112 struct alc_spec *spec = codec->spec;
3113 struct hda_pcm *info = spec->pcm_rec;
3116 codec->num_pcms = 1;
3117 codec->pcm_info = info;
3119 if (spec->no_analog)
3122 info->name = spec->stream_name_analog;
3123 if (spec->stream_analog_playback) {
3124 if (snd_BUG_ON(!spec->multiout.dac_nids))
3126 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3127 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3129 if (spec->stream_analog_capture) {
3130 if (snd_BUG_ON(!spec->adc_nids))
3132 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3133 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3136 if (spec->channel_mode) {
3137 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3138 for (i = 0; i < spec->num_channel_mode; i++) {
3139 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3140 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3146 /* SPDIF for stream index #1 */
3147 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3148 codec->num_pcms = 2;
3149 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3150 info = spec->pcm_rec + 1;
3151 info->name = spec->stream_name_digital;
3152 if (spec->dig_out_type)
3153 info->pcm_type = spec->dig_out_type;
3155 info->pcm_type = HDA_PCM_TYPE_SPDIF;
3156 if (spec->multiout.dig_out_nid &&
3157 spec->stream_digital_playback) {
3158 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3159 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3161 if (spec->dig_in_nid &&
3162 spec->stream_digital_capture) {
3163 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3164 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3166 /* FIXME: do we need this for all Realtek codec models? */
3167 codec->spdif_status_reset = 1;
3170 if (spec->no_analog)
3173 /* If the use of more than one ADC is requested for the current
3174 * model, configure a second analog capture-only PCM.
3176 /* Additional Analaog capture for index #2 */
3177 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3178 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3179 codec->num_pcms = 3;
3180 info = spec->pcm_rec + 2;
3181 info->name = spec->stream_name_analog;
3182 if (spec->alt_dac_nid) {
3183 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3184 *spec->stream_analog_alt_playback;
3185 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3188 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3189 alc_pcm_null_stream;
3190 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3192 if (spec->num_adc_nids > 1) {
3193 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3194 *spec->stream_analog_alt_capture;
3195 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3197 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3198 spec->num_adc_nids - 1;
3200 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3201 alc_pcm_null_stream;
3202 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3209 static void alc_free_kctls(struct hda_codec *codec)
3211 struct alc_spec *spec = codec->spec;
3213 if (spec->kctls.list) {
3214 struct snd_kcontrol_new *kctl = spec->kctls.list;
3216 for (i = 0; i < spec->kctls.used; i++)
3217 kfree(kctl[i].name);
3219 snd_array_free(&spec->kctls);
3222 static void alc_free(struct hda_codec *codec)
3224 struct alc_spec *spec = codec->spec;
3229 alc_free_kctls(codec);
3231 snd_hda_detach_beep_device(codec);
3234 #ifdef SND_HDA_NEEDS_RESUME
3235 static int alc_resume(struct hda_codec *codec)
3237 codec->patch_ops.init(codec);
3238 snd_hda_codec_resume_amp(codec);
3239 snd_hda_codec_resume_cache(codec);
3246 static struct hda_codec_ops alc_patch_ops = {
3247 .build_controls = alc_build_controls,
3248 .build_pcms = alc_build_pcms,
3251 .unsol_event = alc_unsol_event,
3252 #ifdef SND_HDA_NEEDS_RESUME
3253 .resume = alc_resume,
3255 #ifdef CONFIG_SND_HDA_POWER_SAVE
3256 .check_power_status = alc_check_power_status,
3262 * Test configuration for debugging
3264 * Almost all inputs/outputs are enabled. I/O pins can be configured via
3267 #ifdef CONFIG_SND_DEBUG
3268 static hda_nid_t alc880_test_dac_nids[4] = {
3269 0x02, 0x03, 0x04, 0x05
3272 static struct hda_input_mux alc880_test_capture_source = {
3281 { "Surround", 0x6 },
3285 static struct hda_channel_mode alc880_test_modes[4] = {
3292 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3293 struct snd_ctl_elem_info *uinfo)
3295 static char *texts[] = {
3296 "N/A", "Line Out", "HP Out",
3297 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3299 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3301 uinfo->value.enumerated.items = 8;
3302 if (uinfo->value.enumerated.item >= 8)
3303 uinfo->value.enumerated.item = 7;
3304 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3308 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3309 struct snd_ctl_elem_value *ucontrol)
3311 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3312 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3313 unsigned int pin_ctl, item = 0;
3315 pin_ctl = snd_hda_codec_read(codec, nid, 0,
3316 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3317 if (pin_ctl & AC_PINCTL_OUT_EN) {
3318 if (pin_ctl & AC_PINCTL_HP_EN)
3322 } else if (pin_ctl & AC_PINCTL_IN_EN) {
3323 switch (pin_ctl & AC_PINCTL_VREFEN) {
3324 case AC_PINCTL_VREF_HIZ: item = 3; break;
3325 case AC_PINCTL_VREF_50: item = 4; break;
3326 case AC_PINCTL_VREF_GRD: item = 5; break;
3327 case AC_PINCTL_VREF_80: item = 6; break;
3328 case AC_PINCTL_VREF_100: item = 7; break;
3331 ucontrol->value.enumerated.item[0] = item;
3335 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3336 struct snd_ctl_elem_value *ucontrol)
3338 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3339 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3340 static unsigned int ctls[] = {
3341 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3342 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3343 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3344 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3345 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3346 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3348 unsigned int old_ctl, new_ctl;
3350 old_ctl = snd_hda_codec_read(codec, nid, 0,
3351 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3352 new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3353 if (old_ctl != new_ctl) {
3355 snd_hda_codec_write_cache(codec, nid, 0,
3356 AC_VERB_SET_PIN_WIDGET_CONTROL,
3358 val = ucontrol->value.enumerated.item[0] >= 3 ?
3360 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3367 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3368 struct snd_ctl_elem_info *uinfo)
3370 static char *texts[] = {
3371 "Front", "Surround", "CLFE", "Side"
3373 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3375 uinfo->value.enumerated.items = 4;
3376 if (uinfo->value.enumerated.item >= 4)
3377 uinfo->value.enumerated.item = 3;
3378 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3382 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3383 struct snd_ctl_elem_value *ucontrol)
3385 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3386 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3389 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3390 ucontrol->value.enumerated.item[0] = sel & 3;
3394 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3395 struct snd_ctl_elem_value *ucontrol)
3397 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3398 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3401 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3402 if (ucontrol->value.enumerated.item[0] != sel) {
3403 sel = ucontrol->value.enumerated.item[0] & 3;
3404 snd_hda_codec_write_cache(codec, nid, 0,
3405 AC_VERB_SET_CONNECT_SEL, sel);
3411 #define PIN_CTL_TEST(xname,nid) { \
3412 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3414 .info = alc_test_pin_ctl_info, \
3415 .get = alc_test_pin_ctl_get, \
3416 .put = alc_test_pin_ctl_put, \
3417 .private_value = nid \
3420 #define PIN_SRC_TEST(xname,nid) { \
3421 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3423 .info = alc_test_pin_src_info, \
3424 .get = alc_test_pin_src_get, \
3425 .put = alc_test_pin_src_put, \
3426 .private_value = nid \
3429 static struct snd_kcontrol_new alc880_test_mixer[] = {
3430 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3431 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3432 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3433 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3434 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3435 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3436 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3437 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3438 PIN_CTL_TEST("Front Pin Mode", 0x14),
3439 PIN_CTL_TEST("Surround Pin Mode", 0x15),
3440 PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3441 PIN_CTL_TEST("Side Pin Mode", 0x17),
3442 PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3443 PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3444 PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3445 PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3446 PIN_SRC_TEST("In-1 Pin Source", 0x18),
3447 PIN_SRC_TEST("In-2 Pin Source", 0x19),
3448 PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3449 PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3450 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3451 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3452 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3453 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3454 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3455 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3456 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3457 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3458 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3459 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3461 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3462 .name = "Channel Mode",
3463 .info = alc_ch_mode_info,
3464 .get = alc_ch_mode_get,
3465 .put = alc_ch_mode_put,
3470 static struct hda_verb alc880_test_init_verbs[] = {
3471 /* Unmute inputs of 0x0c - 0x0f */
3472 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3473 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3474 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3475 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3476 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3477 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3478 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3479 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3480 /* Vol output for 0x0c-0x0f */
3481 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3482 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3483 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3484 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3485 /* Set output pins 0x14-0x17 */
3486 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3487 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3488 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3489 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3490 /* Unmute output pins 0x14-0x17 */
3491 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3492 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3493 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3494 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3495 /* Set input pins 0x18-0x1c */
3496 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3497 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3498 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3499 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3500 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3501 /* Mute input pins 0x18-0x1b */
3502 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3503 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3504 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3505 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3507 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3508 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3509 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3510 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3511 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3512 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3513 /* Analog input/passthru */
3514 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3515 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3516 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3517 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3518 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3526 static const char *alc880_models[ALC880_MODEL_LAST] = {
3527 [ALC880_3ST] = "3stack",
3528 [ALC880_TCL_S700] = "tcl",
3529 [ALC880_3ST_DIG] = "3stack-digout",
3530 [ALC880_CLEVO] = "clevo",
3531 [ALC880_5ST] = "5stack",
3532 [ALC880_5ST_DIG] = "5stack-digout",
3533 [ALC880_W810] = "w810",
3534 [ALC880_Z71V] = "z71v",
3535 [ALC880_6ST] = "6stack",
3536 [ALC880_6ST_DIG] = "6stack-digout",
3537 [ALC880_ASUS] = "asus",
3538 [ALC880_ASUS_W1V] = "asus-w1v",
3539 [ALC880_ASUS_DIG] = "asus-dig",
3540 [ALC880_ASUS_DIG2] = "asus-dig2",
3541 [ALC880_UNIWILL_DIG] = "uniwill",
3542 [ALC880_UNIWILL_P53] = "uniwill-p53",
3543 [ALC880_FUJITSU] = "fujitsu",
3544 [ALC880_F1734] = "F1734",
3546 [ALC880_LG_LW] = "lg-lw",
3547 [ALC880_MEDION_RIM] = "medion",
3548 #ifdef CONFIG_SND_DEBUG
3549 [ALC880_TEST] = "test",
3551 [ALC880_AUTO] = "auto",
3554 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3555 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3556 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3557 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3558 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3559 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3560 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3561 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3562 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3563 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3564 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3565 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3566 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3567 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3568 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3569 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3570 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3571 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3572 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3573 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3574 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3575 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3576 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3577 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3578 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3579 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3580 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3581 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3582 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3583 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3584 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3585 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3586 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3587 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3588 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3589 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3590 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3591 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3592 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3593 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3594 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3595 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3596 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3597 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3598 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3599 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3600 SND_PCI_QUIRK(0x1695, 0x400d, &