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"
33 #include "hda_patch.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 */
81 #ifdef CONFIG_SND_DEBUG
85 ALC260_MODEL_LAST /* last tag */
95 ALC262_HP_BPC_D7000_WL,
96 ALC262_HP_BPC_D7000_WF,
108 ALC262_MODEL_LAST /* last tag */
117 ALC268_ACER_ASPIRE_ONE,
120 #ifdef CONFIG_SND_DEBUG
124 ALC268_MODEL_LAST /* last tag */
131 ALC269_ASUS_EEEPC_P703,
132 ALC269_ASUS_EEEPC_P901,
134 ALC269_MODEL_LAST /* last tag */
151 /* ALC861-VD models */
172 ALC662_ASUS_EEEPC_P701,
173 ALC662_ASUS_EEEPC_EP20,
212 ALC883_TARGA_2ch_DIG,
218 ALC883_LENOVO_101E_2ch,
219 ALC883_LENOVO_NB0763,
220 ALC888_LENOVO_MS7195_DIG,
227 ALC883_FUJITSU_PI2515,
228 ALC883_3ST_6ch_INTEL,
236 #define GPIO_MASK 0x03
239 /* codec parameterization */
240 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
241 unsigned int num_mixers;
243 const struct hda_verb *init_verbs[5]; /* initialization verbs
247 unsigned int num_init_verbs;
249 char *stream_name_analog; /* analog PCM stream */
250 struct hda_pcm_stream *stream_analog_playback;
251 struct hda_pcm_stream *stream_analog_capture;
252 struct hda_pcm_stream *stream_analog_alt_playback;
253 struct hda_pcm_stream *stream_analog_alt_capture;
255 char *stream_name_digital; /* digital PCM stream */
256 struct hda_pcm_stream *stream_digital_playback;
257 struct hda_pcm_stream *stream_digital_capture;
260 struct hda_multi_out multiout; /* playback set-up
261 * max_channels, dacs must be set
262 * dig_out_nid and hp_nid are optional
264 hda_nid_t alt_dac_nid;
267 unsigned int num_adc_nids;
269 hda_nid_t *capsrc_nids;
270 hda_nid_t dig_in_nid; /* digital-in NID; optional */
273 unsigned int num_mux_defs;
274 const struct hda_input_mux *input_mux;
275 unsigned int cur_mux[3];
278 const struct hda_channel_mode *channel_mode;
279 int num_channel_mode;
282 /* PCM information */
283 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
285 /* dynamic controls, init_verbs and input_mux */
286 struct auto_pin_cfg autocfg;
287 unsigned int num_kctl_alloc, num_kctl_used;
288 struct snd_kcontrol_new *kctl_alloc;
289 struct hda_input_mux private_imux;
290 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
293 void (*init_hook)(struct hda_codec *codec);
294 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
296 /* for pin sensing */
297 unsigned int sense_updated: 1;
298 unsigned int jack_present: 1;
299 unsigned int master_sw: 1;
301 /* for virtual master */
302 hda_nid_t vmaster_nid;
303 #ifdef CONFIG_SND_HDA_POWER_SAVE
304 struct hda_loopback_check loopback;
309 unsigned int pll_coef_idx, pll_coef_bit;
313 * configuration template - to be copied to the spec instance
315 struct alc_config_preset {
316 struct snd_kcontrol_new *mixers[5]; /* should be identical size
319 const struct hda_verb *init_verbs[5];
320 unsigned int num_dacs;
322 hda_nid_t dig_out_nid; /* optional */
323 hda_nid_t hp_nid; /* optional */
324 unsigned int num_adc_nids;
326 hda_nid_t *capsrc_nids;
327 hda_nid_t dig_in_nid;
328 unsigned int num_channel_mode;
329 const struct hda_channel_mode *channel_mode;
331 unsigned int num_mux_defs;
332 const struct hda_input_mux *input_mux;
333 void (*unsol_event)(struct hda_codec *, unsigned int);
334 void (*init_hook)(struct hda_codec *);
335 #ifdef CONFIG_SND_HDA_POWER_SAVE
336 struct hda_amp_list *loopbacks;
344 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
345 struct snd_ctl_elem_info *uinfo)
347 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
348 struct alc_spec *spec = codec->spec;
349 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
350 if (mux_idx >= spec->num_mux_defs)
352 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
355 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
356 struct snd_ctl_elem_value *ucontrol)
358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
359 struct alc_spec *spec = codec->spec;
360 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
362 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
366 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
367 struct snd_ctl_elem_value *ucontrol)
369 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
370 struct alc_spec *spec = codec->spec;
371 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
372 unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
373 hda_nid_t nid = spec->capsrc_nids ?
374 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
375 return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
376 nid, &spec->cur_mux[adc_idx]);
381 * channel mode setting
383 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
384 struct snd_ctl_elem_info *uinfo)
386 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
387 struct alc_spec *spec = codec->spec;
388 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
389 spec->num_channel_mode);
392 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
393 struct snd_ctl_elem_value *ucontrol)
395 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
396 struct alc_spec *spec = codec->spec;
397 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
398 spec->num_channel_mode,
399 spec->multiout.max_channels);
402 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
403 struct snd_ctl_elem_value *ucontrol)
405 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
406 struct alc_spec *spec = codec->spec;
407 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
408 spec->num_channel_mode,
409 &spec->multiout.max_channels);
410 if (err >= 0 && spec->need_dac_fix)
411 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
416 * Control the mode of pin widget settings via the mixer. "pc" is used
417 * instead of "%" to avoid consequences of accidently treating the % as
418 * being part of a format specifier. Maximum allowed length of a value is
419 * 63 characters plus NULL terminator.
421 * Note: some retasking pin complexes seem to ignore requests for input
422 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
423 * are requested. Therefore order this list so that this behaviour will not
424 * cause problems when mixer clients move through the enum sequentially.
425 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
428 static char *alc_pin_mode_names[] = {
429 "Mic 50pc bias", "Mic 80pc bias",
430 "Line in", "Line out", "Headphone out",
432 static unsigned char alc_pin_mode_values[] = {
433 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
435 /* The control can present all 5 options, or it can limit the options based
436 * in the pin being assumed to be exclusively an input or an output pin. In
437 * addition, "input" pins may or may not process the mic bias option
438 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
439 * accept requests for bias as of chip versions up to March 2006) and/or
440 * wiring in the computer.
442 #define ALC_PIN_DIR_IN 0x00
443 #define ALC_PIN_DIR_OUT 0x01
444 #define ALC_PIN_DIR_INOUT 0x02
445 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03
446 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
448 /* Info about the pin modes supported by the different pin direction modes.
449 * For each direction the minimum and maximum values are given.
451 static signed char alc_pin_mode_dir_info[5][2] = {
452 { 0, 2 }, /* ALC_PIN_DIR_IN */
453 { 3, 4 }, /* ALC_PIN_DIR_OUT */
454 { 0, 4 }, /* ALC_PIN_DIR_INOUT */
455 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
456 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
458 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
459 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
460 #define alc_pin_mode_n_items(_dir) \
461 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
463 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
464 struct snd_ctl_elem_info *uinfo)
466 unsigned int item_num = uinfo->value.enumerated.item;
467 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
469 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
471 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
473 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
474 item_num = alc_pin_mode_min(dir);
475 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
479 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
480 struct snd_ctl_elem_value *ucontrol)
483 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
484 hda_nid_t nid = kcontrol->private_value & 0xffff;
485 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
486 long *valp = ucontrol->value.integer.value;
487 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
488 AC_VERB_GET_PIN_WIDGET_CONTROL,
491 /* Find enumerated value for current pinctl setting */
492 i = alc_pin_mode_min(dir);
493 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
495 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
499 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
500 struct snd_ctl_elem_value *ucontrol)
503 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
504 hda_nid_t nid = kcontrol->private_value & 0xffff;
505 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
506 long val = *ucontrol->value.integer.value;
507 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
508 AC_VERB_GET_PIN_WIDGET_CONTROL,
511 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
512 val = alc_pin_mode_min(dir);
514 change = pinctl != alc_pin_mode_values[val];
516 /* Set pin mode to that requested */
517 snd_hda_codec_write_cache(codec, nid, 0,
518 AC_VERB_SET_PIN_WIDGET_CONTROL,
519 alc_pin_mode_values[val]);
521 /* Also enable the retasking pin's input/output as required
522 * for the requested pin mode. Enum values of 2 or less are
525 * Dynamically switching the input/output buffers probably
526 * reduces noise slightly (particularly on input) so we'll
527 * do it. However, having both input and output buffers
528 * enabled simultaneously doesn't seem to be problematic if
529 * this turns out to be necessary in the future.
532 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
533 HDA_AMP_MUTE, HDA_AMP_MUTE);
534 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
537 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
538 HDA_AMP_MUTE, HDA_AMP_MUTE);
539 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
546 #define ALC_PIN_MODE(xname, nid, dir) \
547 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
548 .info = alc_pin_mode_info, \
549 .get = alc_pin_mode_get, \
550 .put = alc_pin_mode_put, \
551 .private_value = nid | (dir<<16) }
553 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
554 * together using a mask with more than one bit set. This control is
555 * currently used only by the ALC260 test model. At this stage they are not
556 * needed for any "production" models.
558 #ifdef CONFIG_SND_DEBUG
559 #define alc_gpio_data_info snd_ctl_boolean_mono_info
561 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
562 struct snd_ctl_elem_value *ucontrol)
564 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
565 hda_nid_t nid = kcontrol->private_value & 0xffff;
566 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
567 long *valp = ucontrol->value.integer.value;
568 unsigned int val = snd_hda_codec_read(codec, nid, 0,
569 AC_VERB_GET_GPIO_DATA, 0x00);
571 *valp = (val & mask) != 0;
574 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
575 struct snd_ctl_elem_value *ucontrol)
578 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
579 hda_nid_t nid = kcontrol->private_value & 0xffff;
580 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
581 long val = *ucontrol->value.integer.value;
582 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
583 AC_VERB_GET_GPIO_DATA,
586 /* Set/unset the masked GPIO bit(s) as needed */
587 change = (val == 0 ? 0 : mask) != (gpio_data & mask);
592 snd_hda_codec_write_cache(codec, nid, 0,
593 AC_VERB_SET_GPIO_DATA, gpio_data);
597 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
598 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
599 .info = alc_gpio_data_info, \
600 .get = alc_gpio_data_get, \
601 .put = alc_gpio_data_put, \
602 .private_value = nid | (mask<<16) }
603 #endif /* CONFIG_SND_DEBUG */
605 /* A switch control to allow the enabling of the digital IO pins on the
606 * ALC260. This is incredibly simplistic; the intention of this control is
607 * to provide something in the test model allowing digital outputs to be
608 * identified if present. If models are found which can utilise these
609 * outputs a more complete mixer control can be devised for those models if
612 #ifdef CONFIG_SND_DEBUG
613 #define alc_spdif_ctrl_info snd_ctl_boolean_mono_info
615 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
616 struct snd_ctl_elem_value *ucontrol)
618 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
619 hda_nid_t nid = kcontrol->private_value & 0xffff;
620 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
621 long *valp = ucontrol->value.integer.value;
622 unsigned int val = snd_hda_codec_read(codec, nid, 0,
623 AC_VERB_GET_DIGI_CONVERT_1, 0x00);
625 *valp = (val & mask) != 0;
628 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
629 struct snd_ctl_elem_value *ucontrol)
632 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
633 hda_nid_t nid = kcontrol->private_value & 0xffff;
634 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
635 long val = *ucontrol->value.integer.value;
636 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
637 AC_VERB_GET_DIGI_CONVERT_1,
640 /* Set/unset the masked control bit(s) as needed */
641 change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
646 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
651 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
652 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
653 .info = alc_spdif_ctrl_info, \
654 .get = alc_spdif_ctrl_get, \
655 .put = alc_spdif_ctrl_put, \
656 .private_value = nid | (mask<<16) }
657 #endif /* CONFIG_SND_DEBUG */
659 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
660 * Again, this is only used in the ALC26x test models to help identify when
661 * the EAPD line must be asserted for features to work.
663 #ifdef CONFIG_SND_DEBUG
664 #define alc_eapd_ctrl_info snd_ctl_boolean_mono_info
666 static int alc_eapd_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_EAPD_BTLENABLE, 0x00);
676 *valp = (val & mask) != 0;
680 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
681 struct snd_ctl_elem_value *ucontrol)
684 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
685 hda_nid_t nid = kcontrol->private_value & 0xffff;
686 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
687 long val = *ucontrol->value.integer.value;
688 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
689 AC_VERB_GET_EAPD_BTLENABLE,
692 /* Set/unset the masked control bit(s) as needed */
693 change = (!val ? 0 : mask) != (ctrl_data & mask);
698 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
704 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
705 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
706 .info = alc_eapd_ctrl_info, \
707 .get = alc_eapd_ctrl_get, \
708 .put = alc_eapd_ctrl_put, \
709 .private_value = nid | (mask<<16) }
710 #endif /* CONFIG_SND_DEBUG */
713 * set up from the preset table
715 static void setup_preset(struct alc_spec *spec,
716 const struct alc_config_preset *preset)
720 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
721 spec->mixers[spec->num_mixers++] = preset->mixers[i];
722 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
724 spec->init_verbs[spec->num_init_verbs++] =
725 preset->init_verbs[i];
727 spec->channel_mode = preset->channel_mode;
728 spec->num_channel_mode = preset->num_channel_mode;
729 spec->need_dac_fix = preset->need_dac_fix;
731 spec->multiout.max_channels = spec->channel_mode[0].channels;
733 spec->multiout.num_dacs = preset->num_dacs;
734 spec->multiout.dac_nids = preset->dac_nids;
735 spec->multiout.dig_out_nid = preset->dig_out_nid;
736 spec->multiout.hp_nid = preset->hp_nid;
738 spec->num_mux_defs = preset->num_mux_defs;
739 if (!spec->num_mux_defs)
740 spec->num_mux_defs = 1;
741 spec->input_mux = preset->input_mux;
743 spec->num_adc_nids = preset->num_adc_nids;
744 spec->adc_nids = preset->adc_nids;
745 spec->capsrc_nids = preset->capsrc_nids;
746 spec->dig_in_nid = preset->dig_in_nid;
748 spec->unsol_event = preset->unsol_event;
749 spec->init_hook = preset->init_hook;
750 #ifdef CONFIG_SND_HDA_POWER_SAVE
751 spec->loopback.amplist = preset->loopbacks;
755 /* Enable GPIO mask and set output */
756 static struct hda_verb alc_gpio1_init_verbs[] = {
757 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
758 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
759 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
763 static struct hda_verb alc_gpio2_init_verbs[] = {
764 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
765 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
766 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
770 static struct hda_verb alc_gpio3_init_verbs[] = {
771 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
772 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
773 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
778 * Fix hardware PLL issue
779 * On some codecs, the analog PLL gating control must be off while
780 * the default value is 1.
782 static void alc_fix_pll(struct hda_codec *codec)
784 struct alc_spec *spec = codec->spec;
789 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
791 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
792 AC_VERB_GET_PROC_COEF, 0);
793 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
795 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
796 val & ~(1 << spec->pll_coef_bit));
799 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
800 unsigned int coef_idx, unsigned int coef_bit)
802 struct alc_spec *spec = codec->spec;
804 spec->pll_coef_idx = coef_idx;
805 spec->pll_coef_bit = coef_bit;
809 static void alc_sku_automute(struct hda_codec *codec)
811 struct alc_spec *spec = codec->spec;
812 unsigned int present;
813 unsigned int hp_nid = spec->autocfg.hp_pins[0];
814 unsigned int sp_nid = spec->autocfg.speaker_pins[0];
816 /* need to execute and sync at first */
817 snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
818 present = snd_hda_codec_read(codec, hp_nid, 0,
819 AC_VERB_GET_PIN_SENSE, 0);
820 spec->jack_present = (present & 0x80000000) != 0;
821 snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
822 spec->jack_present ? 0 : PIN_OUT);
825 static void alc_mic_automute(struct hda_codec *codec)
827 struct alc_spec *spec = codec->spec;
828 unsigned int present;
829 unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
830 unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
831 unsigned int mix_nid = spec->capsrc_nids[0];
832 unsigned int capsrc_idx_mic, capsrc_idx_fmic;
834 capsrc_idx_mic = mic_nid - 0x18;
835 capsrc_idx_fmic = fmic_nid - 0x18;
836 present = snd_hda_codec_read(codec, mic_nid, 0,
837 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
838 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
839 0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
840 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
841 0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
842 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
843 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
846 /* unsolicited event for HP jack sensing */
847 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
849 if (codec->vendor_id == 0x10ec0880)
853 if (res == ALC880_HP_EVENT)
854 alc_sku_automute(codec);
856 if (res == ALC880_MIC_EVENT)
857 alc_mic_automute(codec);
860 static void alc_inithook(struct hda_codec *codec)
862 alc_sku_automute(codec);
863 alc_mic_automute(codec);
866 /* additional initialization for ALC888 variants */
867 static void alc888_coef_init(struct hda_codec *codec)
871 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
872 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
873 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
874 if ((tmp & 0xf0) == 2)
876 snd_hda_codec_read(codec, 0x20, 0,
877 AC_VERB_SET_PROC_COEF, 0x830);
880 snd_hda_codec_read(codec, 0x20, 0,
881 AC_VERB_SET_PROC_COEF, 0x3030);
884 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
885 * 31 ~ 16 : Manufacture ID
887 * 7 ~ 0 : Assembly ID
888 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
890 static void alc_subsystem_id(struct hda_codec *codec,
891 unsigned int porta, unsigned int porte,
894 unsigned int ass, tmp, i;
896 struct alc_spec *spec = codec->spec;
898 ass = codec->subsystem_id & 0xffff;
899 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
903 * 31~30 : port conetcivity
906 * 19~16 : Check sum (15:1)
911 if (codec->vendor_id == 0x10ec0260)
913 ass = snd_hda_codec_read(codec, nid, 0,
914 AC_VERB_GET_CONFIG_DEFAULT, 0);
915 if (!(ass & 1) && !(ass & 0x100000))
917 if ((ass >> 30) != 1) /* no physical connection */
922 for (i = 1; i < 16; i++) {
926 if (((ass >> 16) & 0xf) != tmp)
932 * 2 : 0 --> Desktop, 1 --> Laptop
933 * 3~5 : External Amplifier control
936 tmp = (ass & 0x38) >> 3; /* external Amp control */
939 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
942 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
945 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
947 case 5: /* set EAPD output high */
948 switch (codec->vendor_id) {
950 snd_hda_codec_write(codec, 0x0f, 0,
951 AC_VERB_SET_EAPD_BTLENABLE, 2);
952 snd_hda_codec_write(codec, 0x10, 0,
953 AC_VERB_SET_EAPD_BTLENABLE, 2);
964 snd_hda_codec_write(codec, 0x14, 0,
965 AC_VERB_SET_EAPD_BTLENABLE, 2);
966 snd_hda_codec_write(codec, 0x15, 0,
967 AC_VERB_SET_EAPD_BTLENABLE, 2);
970 switch (codec->vendor_id) {
972 snd_hda_codec_write(codec, 0x1a, 0,
973 AC_VERB_SET_COEF_INDEX, 7);
974 tmp = snd_hda_codec_read(codec, 0x1a, 0,
975 AC_VERB_GET_PROC_COEF, 0);
976 snd_hda_codec_write(codec, 0x1a, 0,
977 AC_VERB_SET_COEF_INDEX, 7);
978 snd_hda_codec_write(codec, 0x1a, 0,
979 AC_VERB_SET_PROC_COEF,
988 snd_hda_codec_write(codec, 0x20, 0,
989 AC_VERB_SET_COEF_INDEX, 7);
990 tmp = snd_hda_codec_read(codec, 0x20, 0,
991 AC_VERB_GET_PROC_COEF, 0);
992 snd_hda_codec_write(codec, 0x20, 0,
993 AC_VERB_SET_COEF_INDEX, 7);
994 snd_hda_codec_write(codec, 0x20, 0,
995 AC_VERB_SET_PROC_COEF,
999 /*alc888_coef_init(codec);*/ /* called in alc_init() */
1003 snd_hda_codec_write(codec, 0x20, 0,
1004 AC_VERB_SET_COEF_INDEX, 7);
1005 tmp = snd_hda_codec_read(codec, 0x20, 0,
1006 AC_VERB_GET_PROC_COEF, 0);
1007 snd_hda_codec_write(codec, 0x20, 0,
1008 AC_VERB_SET_COEF_INDEX, 7);
1009 snd_hda_codec_write(codec, 0x20, 0,
1010 AC_VERB_SET_PROC_COEF,
1018 /* is laptop or Desktop and enable the function "Mute internal speaker
1019 * when the external headphone out jack is plugged"
1021 if (!(ass & 0x8000))
1024 * 10~8 : Jack location
1025 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1027 * 15 : 1 --> enable the function "Mute internal speaker
1028 * when the external headphone out jack is plugged"
1030 if (!spec->autocfg.speaker_pins[0]) {
1031 if (spec->autocfg.line_out_pins[0])
1032 spec->autocfg.speaker_pins[0] =
1033 spec->autocfg.line_out_pins[0];
1038 if (!spec->autocfg.hp_pins[0]) {
1039 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1041 spec->autocfg.hp_pins[0] = porta;
1043 spec->autocfg.hp_pins[0] = porte;
1045 spec->autocfg.hp_pins[0] = portd;
1049 if (spec->autocfg.hp_pins[0])
1050 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1051 AC_VERB_SET_UNSOLICITED_ENABLE,
1052 AC_USRSP_EN | ALC880_HP_EVENT);
1054 if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1055 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1056 snd_hda_codec_write(codec,
1057 spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1058 AC_VERB_SET_UNSOLICITED_ENABLE,
1059 AC_USRSP_EN | ALC880_MIC_EVENT);
1061 spec->unsol_event = alc_sku_unsol_event;
1065 * Fix-up pin default configurations
1073 static void alc_fix_pincfg(struct hda_codec *codec,
1074 const struct snd_pci_quirk *quirk,
1075 const struct alc_pincfg **pinfix)
1077 const struct alc_pincfg *cfg;
1079 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1083 cfg = pinfix[quirk->value];
1084 for (; cfg->nid; cfg++) {
1087 for (i = 0; i < 4; i++) {
1088 snd_hda_codec_write(codec, cfg->nid, 0,
1089 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1097 * ALC880 3-stack model
1099 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1100 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1101 * F-Mic = 0x1b, HP = 0x19
1104 static hda_nid_t alc880_dac_nids[4] = {
1105 /* front, rear, clfe, rear_surr */
1106 0x02, 0x05, 0x04, 0x03
1109 static hda_nid_t alc880_adc_nids[3] = {
1114 /* The datasheet says the node 0x07 is connected from inputs,
1115 * but it shows zero connection in the real implementation on some devices.
1116 * Note: this is a 915GAV bug, fixed on 915GLV
1118 static hda_nid_t alc880_adc_nids_alt[2] = {
1123 #define ALC880_DIGOUT_NID 0x06
1124 #define ALC880_DIGIN_NID 0x0a
1126 static struct hda_input_mux alc880_capture_source = {
1130 { "Front Mic", 0x3 },
1136 /* channel source setting (2/6 channel selection for 3-stack) */
1138 static struct hda_verb alc880_threestack_ch2_init[] = {
1139 /* set line-in to input, mute it */
1140 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1141 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1142 /* set mic-in to input vref 80%, mute it */
1143 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1144 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1149 static struct hda_verb alc880_threestack_ch6_init[] = {
1150 /* set line-in to output, unmute it */
1151 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1152 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1153 /* set mic-in to output, unmute it */
1154 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1155 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1159 static struct hda_channel_mode alc880_threestack_modes[2] = {
1160 { 2, alc880_threestack_ch2_init },
1161 { 6, alc880_threestack_ch6_init },
1164 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1165 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1166 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1167 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1168 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1169 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1170 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1171 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1172 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1173 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1174 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1175 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1176 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1177 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1178 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1179 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1180 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1181 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1182 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1183 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1185 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1186 .name = "Channel Mode",
1187 .info = alc_ch_mode_info,
1188 .get = alc_ch_mode_get,
1189 .put = alc_ch_mode_put,
1194 /* capture mixer elements */
1195 static struct snd_kcontrol_new alc880_capture_mixer[] = {
1196 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
1197 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
1198 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
1199 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
1200 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
1201 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
1203 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1204 /* The multiple "Capture Source" controls confuse alsamixer
1205 * So call somewhat different..
1207 /* .name = "Capture Source", */
1208 .name = "Input Source",
1210 .info = alc_mux_enum_info,
1211 .get = alc_mux_enum_get,
1212 .put = alc_mux_enum_put,
1217 /* capture mixer elements (in case NID 0x07 not available) */
1218 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
1219 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1220 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1221 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
1222 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
1224 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1225 /* The multiple "Capture Source" controls confuse alsamixer
1226 * So call somewhat different..
1228 /* .name = "Capture Source", */
1229 .name = "Input Source",
1231 .info = alc_mux_enum_info,
1232 .get = alc_mux_enum_get,
1233 .put = alc_mux_enum_put,
1241 * ALC880 5-stack model
1243 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1245 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1246 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1249 /* additional mixers to alc880_three_stack_mixer */
1250 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1251 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1252 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1256 /* channel source setting (6/8 channel selection for 5-stack) */
1258 static struct hda_verb alc880_fivestack_ch6_init[] = {
1259 /* set line-in to input, mute it */
1260 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1261 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1266 static struct hda_verb alc880_fivestack_ch8_init[] = {
1267 /* set line-in to output, unmute it */
1268 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1269 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1273 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1274 { 6, alc880_fivestack_ch6_init },
1275 { 8, alc880_fivestack_ch8_init },
1280 * ALC880 6-stack model
1282 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1283 * Side = 0x05 (0x0f)
1284 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1285 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1288 static hda_nid_t alc880_6st_dac_nids[4] = {
1289 /* front, rear, clfe, rear_surr */
1290 0x02, 0x03, 0x04, 0x05
1293 static struct hda_input_mux alc880_6stack_capture_source = {
1297 { "Front Mic", 0x1 },
1303 /* fixed 8-channels */
1304 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1308 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1309 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1310 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1311 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1312 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1313 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1314 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1315 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1316 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1317 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1318 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1319 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1320 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1321 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1322 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1323 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1324 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1325 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1326 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1327 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1328 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1330 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1331 .name = "Channel Mode",
1332 .info = alc_ch_mode_info,
1333 .get = alc_ch_mode_get,
1334 .put = alc_ch_mode_put,
1343 * W810 has rear IO for:
1346 * Center/LFE (DAC 04)
1349 * The system also has a pair of internal speakers, and a headphone jack.
1350 * These are both connected to Line2 on the codec, hence to DAC 02.
1352 * There is a variable resistor to control the speaker or headphone
1353 * volume. This is a hardware-only device without a software API.
1355 * Plugging headphones in will disable the internal speakers. This is
1356 * implemented in hardware, not via the driver using jack sense. In
1357 * a similar fashion, plugging into the rear socket marked "front" will
1358 * disable both the speakers and headphones.
1360 * For input, there's a microphone jack, and an "audio in" jack.
1361 * These may not do anything useful with this driver yet, because I
1362 * haven't setup any initialization verbs for these yet...
1365 static hda_nid_t alc880_w810_dac_nids[3] = {
1366 /* front, rear/surround, clfe */
1370 /* fixed 6 channels */
1371 static struct hda_channel_mode alc880_w810_modes[1] = {
1375 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1376 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1377 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1378 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1379 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1380 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1381 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1382 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1383 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1384 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1385 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1393 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1394 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1398 static hda_nid_t alc880_z71v_dac_nids[1] = {
1401 #define ALC880_Z71V_HP_DAC 0x03
1403 /* fixed 2 channels */
1404 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1408 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1409 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1410 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1411 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1412 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1413 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1414 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1415 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1416 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1422 * ALC880 F1734 model
1424 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1425 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1428 static hda_nid_t alc880_f1734_dac_nids[1] = {
1431 #define ALC880_F1734_HP_DAC 0x02
1433 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1434 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1435 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1436 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1437 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1438 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1439 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1440 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1441 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1445 static struct hda_input_mux alc880_f1734_capture_source = {
1457 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1458 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1459 * Mic = 0x18, Line = 0x1a
1462 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */
1463 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */
1465 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1466 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1467 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1468 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1469 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1470 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1471 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1472 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1473 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1474 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1475 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1476 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1477 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1478 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1479 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1481 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1482 .name = "Channel Mode",
1483 .info = alc_ch_mode_info,
1484 .get = alc_ch_mode_get,
1485 .put = alc_ch_mode_put,
1491 * ALC880 ASUS W1V model
1493 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1494 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1495 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1498 /* additional mixers to alc880_asus_mixer */
1499 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1500 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1501 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1505 /* additional mixers to alc880_asus_mixer */
1506 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1507 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1508 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1513 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1514 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1515 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1516 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1517 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1518 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1519 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1520 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1521 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1522 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1524 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1525 /* The multiple "Capture Source" controls confuse alsamixer
1526 * So call somewhat different..
1528 /* .name = "Capture Source", */
1529 .name = "Input Source",
1531 .info = alc_mux_enum_info,
1532 .get = alc_mux_enum_get,
1533 .put = alc_mux_enum_put,
1539 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1540 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1541 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1542 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1543 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1544 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1545 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1546 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1547 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1548 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1549 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1550 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1551 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1552 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1553 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1554 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1555 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1556 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1557 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1559 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1560 .name = "Channel Mode",
1561 .info = alc_ch_mode_info,
1562 .get = alc_ch_mode_get,
1563 .put = alc_ch_mode_put,
1568 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1569 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1570 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1571 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1572 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1573 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1574 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1575 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1576 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1577 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1578 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1582 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1583 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1584 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1585 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1586 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1587 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1588 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1593 * virtual master controls
1597 * slave controls for virtual master
1599 static const char *alc_slave_vols[] = {
1600 "Front Playback Volume",
1601 "Surround Playback Volume",
1602 "Center Playback Volume",
1603 "LFE Playback Volume",
1604 "Side Playback Volume",
1605 "Headphone Playback Volume",
1606 "Speaker Playback Volume",
1607 "Mono Playback Volume",
1608 "Line-Out Playback Volume",
1612 static const char *alc_slave_sws[] = {
1613 "Front Playback Switch",
1614 "Surround Playback Switch",
1615 "Center Playback Switch",
1616 "LFE Playback Switch",
1617 "Side Playback Switch",
1618 "Headphone Playback Switch",
1619 "Speaker Playback Switch",
1620 "Mono Playback Switch",
1621 "IEC958 Playback Switch",
1626 * build control elements
1628 static int alc_build_controls(struct hda_codec *codec)
1630 struct alc_spec *spec = codec->spec;
1634 for (i = 0; i < spec->num_mixers; i++) {
1635 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1640 if (spec->multiout.dig_out_nid) {
1641 err = snd_hda_create_spdif_out_ctls(codec,
1642 spec->multiout.dig_out_nid);
1645 err = snd_hda_create_spdif_share_sw(codec,
1649 spec->multiout.share_spdif = 1;
1651 if (spec->dig_in_nid) {
1652 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1657 /* if we have no master control, let's create it */
1658 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1659 unsigned int vmaster_tlv[4];
1660 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1661 HDA_OUTPUT, vmaster_tlv);
1662 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1663 vmaster_tlv, alc_slave_vols);
1667 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1668 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1669 NULL, alc_slave_sws);
1679 * initialize the codec volumes, etc
1683 * generic initialization of ADC, input mixers and output mixers
1685 static struct hda_verb alc880_volume_init_verbs[] = {
1687 * Unmute ADC0-2 and set the default input to mic-in
1689 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1690 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1691 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1692 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1693 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1694 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1696 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1698 * Note: PASD motherboards uses the Line In 2 as the input for front
1701 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1702 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1703 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1704 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1705 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1706 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1707 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1708 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1711 * Set up output mixers (0x0c - 0x0f)
1713 /* set vol=0 to output mixers */
1714 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1715 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1716 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1717 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1718 /* set up input amps for analog loopback */
1719 /* Amp Indices: DAC = 0, mixer = 1 */
1720 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1721 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1722 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1723 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1724 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1725 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1726 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1727 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1733 * 3-stack pin configuration:
1734 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1736 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1738 * preset connection lists of input pins
1739 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1741 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1742 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1743 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1746 * Set pin mode and muting
1748 /* set front pin widgets 0x14 for output */
1749 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1750 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1751 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1752 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1753 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1754 /* Mic2 (as headphone out) for HP output */
1755 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1756 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1757 /* Line In pin widget for input */
1758 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1759 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1760 /* Line2 (as front mic) pin widget for input and vref at 80% */
1761 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1762 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1763 /* CD pin widget for input */
1764 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1770 * 5-stack pin configuration:
1771 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1772 * line-in/side = 0x1a, f-mic = 0x1b
1774 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1776 * preset connection lists of input pins
1777 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1779 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1780 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1783 * Set pin mode and muting
1785 /* set pin widgets 0x14-0x17 for output */
1786 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1787 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1788 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1789 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1790 /* unmute pins for output (no gain on this amp) */
1791 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1792 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1793 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1794 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1796 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1797 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1798 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1799 /* Mic2 (as headphone out) for HP output */
1800 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1801 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1802 /* Line In pin widget for input */
1803 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1804 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1805 /* Line2 (as front mic) pin widget for input and vref at 80% */
1806 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1807 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1808 /* CD pin widget for input */
1809 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1815 * W810 pin configuration:
1816 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1818 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1819 /* hphone/speaker input selector: front DAC */
1820 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1822 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1823 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1824 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1825 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1826 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1827 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1829 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1830 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1836 * Z71V pin configuration:
1837 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1839 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1840 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1841 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1842 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1843 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1845 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1846 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1847 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1848 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1854 * 6-stack pin configuration:
1855 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1856 * f-mic = 0x19, line = 0x1a, HP = 0x1b
1858 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1859 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1861 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1862 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1863 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1864 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1865 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1866 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1867 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1868 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1870 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1871 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1872 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1873 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1874 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1875 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1876 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1877 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1878 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1884 * Uniwill pin configuration:
1885 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1888 static struct hda_verb alc880_uniwill_init_verbs[] = {
1889 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1891 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1892 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1893 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1894 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1895 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1896 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1897 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1898 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1899 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1900 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1901 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1902 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1903 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1904 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1906 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1907 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1908 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1909 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1910 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1911 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1912 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1913 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1914 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1916 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1917 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1924 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1926 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1927 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1929 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1930 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1931 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1932 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1933 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1934 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1935 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1936 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1937 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1938 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1939 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1940 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1942 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1943 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1944 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1945 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1946 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1947 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1949 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1950 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1955 static struct hda_verb alc880_beep_init_verbs[] = {
1956 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1960 /* toggle speaker-output according to the hp-jack state */
1961 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
1963 unsigned int present;
1966 present = snd_hda_codec_read(codec, 0x14, 0,
1967 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1968 bits = present ? HDA_AMP_MUTE : 0;
1969 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1970 HDA_AMP_MUTE, bits);
1971 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
1972 HDA_AMP_MUTE, bits);
1975 /* auto-toggle front mic */
1976 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
1978 unsigned int present;
1981 present = snd_hda_codec_read(codec, 0x18, 0,
1982 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1983 bits = present ? HDA_AMP_MUTE : 0;
1984 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
1987 static void alc880_uniwill_automute(struct hda_codec *codec)
1989 alc880_uniwill_hp_automute(codec);
1990 alc880_uniwill_mic_automute(codec);
1993 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
1996 /* Looks like the unsol event is incompatible with the standard
1997 * definition. 4bit tag is placed at 28 bit!
1999 switch (res >> 28) {
2000 case ALC880_HP_EVENT:
2001 alc880_uniwill_hp_automute(codec);
2003 case ALC880_MIC_EVENT:
2004 alc880_uniwill_mic_automute(codec);
2009 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2011 unsigned int present;
2014 present = snd_hda_codec_read(codec, 0x14, 0,
2015 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2016 bits = present ? HDA_AMP_MUTE : 0;
2017 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2020 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2022 unsigned int present;
2024 present = snd_hda_codec_read(codec, 0x21, 0,
2025 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2026 present &= HDA_AMP_VOLMASK;
2027 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2028 HDA_AMP_VOLMASK, present);
2029 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2030 HDA_AMP_VOLMASK, present);
2033 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2036 /* Looks like the unsol event is incompatible with the standard
2037 * definition. 4bit tag is placed at 28 bit!
2039 if ((res >> 28) == ALC880_HP_EVENT)
2040 alc880_uniwill_p53_hp_automute(codec);
2041 if ((res >> 28) == ALC880_DCVOL_EVENT)
2042 alc880_uniwill_p53_dcvol_automute(codec);
2046 * F1734 pin configuration:
2047 * HP = 0x14, speaker-out = 0x15, mic = 0x18
2049 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2050 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2051 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2052 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2053 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2054 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2056 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2057 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2058 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2059 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2061 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2062 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2063 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2064 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2065 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2066 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2067 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2068 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2069 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2071 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2072 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2078 * ASUS pin configuration:
2079 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2081 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2082 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2083 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2084 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2085 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2087 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2088 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2089 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2090 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2091 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2092 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2093 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2094 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2096 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2097 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2098 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2099 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2100 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2101 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2102 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2103 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2104 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2109 /* Enable GPIO mask and set output */
2110 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2111 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2113 /* Clevo m520g init */
2114 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2115 /* headphone output */
2116 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2118 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2119 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2121 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2122 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2124 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2125 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2126 /* Mic1 (rear panel) */
2127 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2128 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2129 /* Mic2 (front panel) */
2130 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2131 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2133 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2134 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2135 /* change to EAPD mode */
2136 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2137 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2142 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2143 /* change to EAPD mode */
2144 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2145 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2147 /* Headphone output */
2148 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2150 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2151 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2153 /* Line In pin widget for input */
2154 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2155 /* CD pin widget for input */
2156 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2157 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2158 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2160 /* change to EAPD mode */
2161 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2162 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
2168 * LG m1 express dual
2171 * Rear Line-In/Out (blue): 0x14
2172 * Build-in Mic-In: 0x15
2174 * HP-Out (green): 0x1b
2175 * Mic-In/Out (red): 0x19
2179 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2180 static hda_nid_t alc880_lg_dac_nids[3] = {
2184 /* seems analog CD is not working */
2185 static struct hda_input_mux alc880_lg_capture_source = {
2190 { "Internal Mic", 0x6 },
2194 /* 2,4,6 channel modes */
2195 static struct hda_verb alc880_lg_ch2_init[] = {
2196 /* set line-in and mic-in to input */
2197 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2198 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2202 static struct hda_verb alc880_lg_ch4_init[] = {
2203 /* set line-in to out and mic-in to input */
2204 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2205 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2209 static struct hda_verb alc880_lg_ch6_init[] = {
2210 /* set line-in and mic-in to output */
2211 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2212 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2216 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2217 { 2, alc880_lg_ch2_init },
2218 { 4, alc880_lg_ch4_init },
2219 { 6, alc880_lg_ch6_init },
2222 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2223 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2224 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2225 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2226 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2227 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2228 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2229 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2230 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2231 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2232 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2233 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2234 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2235 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2236 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2238 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2239 .name = "Channel Mode",
2240 .info = alc_ch_mode_info,
2241 .get = alc_ch_mode_get,
2242 .put = alc_ch_mode_put,
2247 static struct hda_verb alc880_lg_init_verbs[] = {
2248 /* set capture source to mic-in */
2249 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2250 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2251 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2252 /* mute all amp mixer inputs */
2253 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2254 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2255 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2256 /* line-in to input */
2257 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2258 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2260 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2261 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2263 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2264 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2265 /* mic-in to input */
2266 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2267 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2268 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2270 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2271 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2272 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2274 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2278 /* toggle speaker-output according to the hp-jack state */
2279 static void alc880_lg_automute(struct hda_codec *codec)
2281 unsigned int present;
2284 present = snd_hda_codec_read(codec, 0x1b, 0,
2285 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2286 bits = present ? HDA_AMP_MUTE : 0;
2287 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2288 HDA_AMP_MUTE, bits);
2291 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2293 /* Looks like the unsol event is incompatible with the standard
2294 * definition. 4bit tag is placed at 28 bit!
2296 if ((res >> 28) == 0x01)
2297 alc880_lg_automute(codec);
2306 * Built-in Mic-In: 0x19
2312 static struct hda_input_mux alc880_lg_lw_capture_source = {
2316 { "Internal Mic", 0x1 },
2321 #define alc880_lg_lw_modes alc880_threestack_modes
2323 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2324 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2325 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2326 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2327 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2328 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2329 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2330 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2331 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2332 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2333 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2334 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2335 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2336 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2337 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2339 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2340 .name = "Channel Mode",
2341 .info = alc_ch_mode_info,
2342 .get = alc_ch_mode_get,
2343 .put = alc_ch_mode_put,
2348 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2349 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2350 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2351 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2353 /* set capture source to mic-in */
2354 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2355 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2356 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2357 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2359 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2360 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2362 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2363 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2364 /* mic-in to input */
2365 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2366 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2368 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2369 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2371 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2375 /* toggle speaker-output according to the hp-jack state */
2376 static void alc880_lg_lw_automute(struct hda_codec *codec)
2378 unsigned int present;
2381 present = snd_hda_codec_read(codec, 0x1b, 0,
2382 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2383 bits = present ? HDA_AMP_MUTE : 0;
2384 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2385 HDA_AMP_MUTE, bits);
2388 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2390 /* Looks like the unsol event is incompatible with the standard
2391 * definition. 4bit tag is placed at 28 bit!
2393 if ((res >> 28) == 0x01)
2394 alc880_lg_lw_automute(codec);
2397 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2398 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2399 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2400 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2401 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2402 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2403 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2407 static struct hda_input_mux alc880_medion_rim_capture_source = {
2411 { "Internal Mic", 0x1 },
2415 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2416 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2418 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2419 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2421 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2422 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2423 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2424 /* Mic2 (as headphone out) for HP output */
2425 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2426 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2427 /* Internal Speaker */
2428 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2429 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2431 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2432 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2434 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2438 /* toggle speaker-output according to the hp-jack state */
2439 static void alc880_medion_rim_automute(struct hda_codec *codec)
2441 unsigned int present;
2444 present = snd_hda_codec_read(codec, 0x14, 0,
2445 AC_VERB_GET_PIN_SENSE, 0)
2446 & AC_PINSENSE_PRESENCE;
2447 bits = present ? HDA_AMP_MUTE : 0;
2448 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2449 HDA_AMP_MUTE, bits);
2451 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2453 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2456 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2459 /* Looks like the unsol event is incompatible with the standard
2460 * definition. 4bit tag is placed at 28 bit!
2462 if ((res >> 28) == ALC880_HP_EVENT)
2463 alc880_medion_rim_automute(codec);
2466 #ifdef CONFIG_SND_HDA_POWER_SAVE
2467 static struct hda_amp_list alc880_loopbacks[] = {
2468 { 0x0b, HDA_INPUT, 0 },
2469 { 0x0b, HDA_INPUT, 1 },
2470 { 0x0b, HDA_INPUT, 2 },
2471 { 0x0b, HDA_INPUT, 3 },
2472 { 0x0b, HDA_INPUT, 4 },
2476 static struct hda_amp_list alc880_lg_loopbacks[] = {
2477 { 0x0b, HDA_INPUT, 1 },
2478 { 0x0b, HDA_INPUT, 6 },
2479 { 0x0b, HDA_INPUT, 7 },
2488 static int alc_init(struct hda_codec *codec)
2490 struct alc_spec *spec = codec->spec;
2494 if (codec->vendor_id == 0x10ec0888)
2495 alc888_coef_init(codec);
2497 for (i = 0; i < spec->num_init_verbs; i++)
2498 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2500 if (spec->init_hook)
2501 spec->init_hook(codec);
2506 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2508 struct alc_spec *spec = codec->spec;
2510 if (spec->unsol_event)
2511 spec->unsol_event(codec, res);
2514 #ifdef CONFIG_SND_HDA_POWER_SAVE
2515 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2517 struct alc_spec *spec = codec->spec;
2518 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2523 * Analog playback callbacks
2525 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2526 struct hda_codec *codec,
2527 struct snd_pcm_substream *substream)
2529 struct alc_spec *spec = codec->spec;
2530 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2534 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2535 struct hda_codec *codec,
2536 unsigned int stream_tag,
2537 unsigned int format,
2538 struct snd_pcm_substream *substream)
2540 struct alc_spec *spec = codec->spec;
2541 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2542 stream_tag, format, substream);
2545 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2546 struct hda_codec *codec,
2547 struct snd_pcm_substream *substream)
2549 struct alc_spec *spec = codec->spec;
2550 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2556 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2557 struct hda_codec *codec,
2558 struct snd_pcm_substream *substream)
2560 struct alc_spec *spec = codec->spec;
2561 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2564 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2565 struct hda_codec *codec,
2566 unsigned int stream_tag,
2567 unsigned int format,
2568 struct snd_pcm_substream *substream)
2570 struct alc_spec *spec = codec->spec;
2571 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2572 stream_tag, format, substream);
2575 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2576 struct hda_codec *codec,
2577 struct snd_pcm_substream *substream)
2579 struct alc_spec *spec = codec->spec;
2580 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2586 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2587 struct hda_codec *codec,
2588 unsigned int stream_tag,
2589 unsigned int format,
2590 struct snd_pcm_substream *substream)
2592 struct alc_spec *spec = codec->spec;
2594 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2595 stream_tag, 0, format);
2599 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2600 struct hda_codec *codec,
2601 struct snd_pcm_substream *substream)
2603 struct alc_spec *spec = codec->spec;
2605 snd_hda_codec_cleanup_stream(codec,
2606 spec->adc_nids[substream->number + 1]);
2613 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2617 /* NID is set in alc_build_pcms */
2619 .open = alc880_playback_pcm_open,
2620 .prepare = alc880_playback_pcm_prepare,
2621 .cleanup = alc880_playback_pcm_cleanup
2625 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2629 /* NID is set in alc_build_pcms */
2632 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
2636 /* NID is set in alc_build_pcms */
2639 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
2640 .substreams = 2, /* can be overridden */
2643 /* NID is set in alc_build_pcms */
2645 .prepare = alc880_alt_capture_pcm_prepare,
2646 .cleanup = alc880_alt_capture_pcm_cleanup
2650 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2654 /* NID is set in alc_build_pcms */
2656 .open = alc880_dig_playback_pcm_open,
2657 .close = alc880_dig_playback_pcm_close,
2658 .prepare = alc880_dig_playback_pcm_prepare
2662 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2666 /* NID is set in alc_build_pcms */
2669 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2670 static struct hda_pcm_stream alc_pcm_null_stream = {
2676 static int alc_build_pcms(struct hda_codec *codec)
2678 struct alc_spec *spec = codec->spec;
2679 struct hda_pcm *info = spec->pcm_rec;
2682 codec->num_pcms = 1;
2683 codec->pcm_info = info;
2685 info->name = spec->stream_name_analog;
2686 if (spec->stream_analog_playback) {
2687 if (snd_BUG_ON(!spec->multiout.dac_nids))
2689 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2690 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2692 if (spec->stream_analog_capture) {
2693 if (snd_BUG_ON(!spec->adc_nids))
2695 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2696 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2699 if (spec->channel_mode) {
2700 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2701 for (i = 0; i < spec->num_channel_mode; i++) {
2702 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2703 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2708 /* SPDIF for stream index #1 */
2709 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2710 codec->num_pcms = 2;
2711 info = spec->pcm_rec + 1;
2712 info->name = spec->stream_name_digital;
2713 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2714 if (spec->multiout.dig_out_nid &&
2715 spec->stream_digital_playback) {
2716 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2717 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2719 if (spec->dig_in_nid &&
2720 spec->stream_digital_capture) {
2721 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2722 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2724 /* FIXME: do we need this for all Realtek codec models? */
2725 codec->spdif_status_reset = 1;
2728 /* If the use of more than one ADC is requested for the current
2729 * model, configure a second analog capture-only PCM.
2731 /* Additional Analaog capture for index #2 */
2732 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
2733 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
2734 codec->num_pcms = 3;
2735 info = spec->pcm_rec + 2;
2736 info->name = spec->stream_name_analog;
2737 if (spec->alt_dac_nid) {
2738 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2739 *spec->stream_analog_alt_playback;
2740 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2743 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2744 alc_pcm_null_stream;
2745 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2747 if (spec->num_adc_nids > 1) {
2748 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2749 *spec->stream_analog_alt_capture;
2750 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2752 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2753 spec->num_adc_nids - 1;
2755 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2756 alc_pcm_null_stream;
2757 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2764 static void alc_free(struct hda_codec *codec)
2766 struct alc_spec *spec = codec->spec;
2772 if (spec->kctl_alloc) {
2773 for (i = 0; i < spec->num_kctl_used; i++)
2774 kfree(spec->kctl_alloc[i].name);
2775 kfree(spec->kctl_alloc);
2778 codec->spec = NULL; /* to be sure */
2783 static struct hda_codec_ops alc_patch_ops = {
2784 .build_controls = alc_build_controls,
2785 .build_pcms = alc_build_pcms,
2788 .unsol_event = alc_unsol_event,
2789 #ifdef CONFIG_SND_HDA_POWER_SAVE
2790 .check_power_status = alc_check_power_status,
2796 * Test configuration for debugging
2798 * Almost all inputs/outputs are enabled. I/O pins can be configured via
2801 #ifdef CONFIG_SND_DEBUG
2802 static hda_nid_t alc880_test_dac_nids[4] = {
2803 0x02, 0x03, 0x04, 0x05
2806 static struct hda_input_mux alc880_test_capture_source = {
2815 { "Surround", 0x6 },
2819 static struct hda_channel_mode alc880_test_modes[4] = {
2826 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2827 struct snd_ctl_elem_info *uinfo)
2829 static char *texts[] = {
2830 "N/A", "Line Out", "HP Out",
2831 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2833 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2835 uinfo->value.enumerated.items = 8;
2836 if (uinfo->value.enumerated.item >= 8)
2837 uinfo->value.enumerated.item = 7;
2838 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2842 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
2843 struct snd_ctl_elem_value *ucontrol)
2845 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2846 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2847 unsigned int pin_ctl, item = 0;
2849 pin_ctl = snd_hda_codec_read(codec, nid, 0,
2850 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2851 if (pin_ctl & AC_PINCTL_OUT_EN) {
2852 if (pin_ctl & AC_PINCTL_HP_EN)
2856 } else if (pin_ctl & AC_PINCTL_IN_EN) {
2857 switch (pin_ctl & AC_PINCTL_VREFEN) {
2858 case AC_PINCTL_VREF_HIZ: item = 3; break;
2859 case AC_PINCTL_VREF_50: item = 4; break;
2860 case AC_PINCTL_VREF_GRD: item = 5; break;
2861 case AC_PINCTL_VREF_80: item = 6; break;
2862 case AC_PINCTL_VREF_100: item = 7; break;
2865 ucontrol->value.enumerated.item[0] = item;
2869 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2870 struct snd_ctl_elem_value *ucontrol)
2872 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2873 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2874 static unsigned int ctls[] = {
2875 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2876 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2877 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2878 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2879 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2880 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2882 unsigned int old_ctl, new_ctl;
2884 old_ctl = snd_hda_codec_read(codec, nid, 0,
2885 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2886 new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2887 if (old_ctl != new_ctl) {
2889 snd_hda_codec_write_cache(codec, nid, 0,
2890 AC_VERB_SET_PIN_WIDGET_CONTROL,
2892 val = ucontrol->value.enumerated.item[0] >= 3 ?
2894 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2901 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2902 struct snd_ctl_elem_info *uinfo)
2904 static char *texts[] = {
2905 "Front", "Surround", "CLFE", "Side"
2907 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2909 uinfo->value.enumerated.items = 4;
2910 if (uinfo->value.enumerated.item >= 4)
2911 uinfo->value.enumerated.item = 3;
2912 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2916 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2917 struct snd_ctl_elem_value *ucontrol)
2919 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2920 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2923 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2924 ucontrol->value.enumerated.item[0] = sel & 3;
2928 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
2929 struct snd_ctl_elem_value *ucontrol)
2931 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2932 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2935 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
2936 if (ucontrol->value.enumerated.item[0] != sel) {
2937 sel = ucontrol->value.enumerated.item[0] & 3;
2938 snd_hda_codec_write_cache(codec, nid, 0,
2939 AC_VERB_SET_CONNECT_SEL, sel);
2945 #define PIN_CTL_TEST(xname,nid) { \
2946 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2948 .info = alc_test_pin_ctl_info, \
2949 .get = alc_test_pin_ctl_get, \
2950 .put = alc_test_pin_ctl_put, \
2951 .private_value = nid \
2954 #define PIN_SRC_TEST(xname,nid) { \
2955 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2957 .info = alc_test_pin_src_info, \
2958 .get = alc_test_pin_src_get, \
2959 .put = alc_test_pin_src_put, \
2960 .private_value = nid \
2963 static struct snd_kcontrol_new alc880_test_mixer[] = {
2964 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2965 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2966 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
2967 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2968 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2969 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2970 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
2971 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2972 PIN_CTL_TEST("Front Pin Mode", 0x14),
2973 PIN_CTL_TEST("Surround Pin Mode", 0x15),
2974 PIN_CTL_TEST("CLFE Pin Mode", 0x16),
2975 PIN_CTL_TEST("Side Pin Mode", 0x17),
2976 PIN_CTL_TEST("In-1 Pin Mode", 0x18),
2977 PIN_CTL_TEST("In-2 Pin Mode", 0x19),
2978 PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
2979 PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
2980 PIN_SRC_TEST("In-1 Pin Source", 0x18),
2981 PIN_SRC_TEST("In-2 Pin Source", 0x19),
2982 PIN_SRC_TEST("In-3 Pin Source", 0x1a),
2983 PIN_SRC_TEST("In-4 Pin Source", 0x1b),
2984 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
2985 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
2986 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
2987 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
2988 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
2989 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
2990 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
2991 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
2992 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
2993 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
2995 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2996 .name = "Channel Mode",
2997 .info = alc_ch_mode_info,
2998 .get = alc_ch_mode_get,
2999 .put = alc_ch_mode_put,
3004 static struct hda_verb alc880_test_init_verbs[] = {
3005 /* Unmute inputs of 0x0c - 0x0f */
3006 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3007 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3008 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3009 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3010 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3011 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3012 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3013 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3014 /* Vol output for 0x0c-0x0f */
3015 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3016 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3017 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3018 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3019 /* Set output pins 0x14-0x17 */
3020 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3021 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3022 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3023 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3024 /* Unmute output pins 0x14-0x17 */
3025 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3026 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3027 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3028 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3029 /* Set input pins 0x18-0x1c */
3030 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3031 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3032 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3033 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3034 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3035 /* Mute input pins 0x18-0x1b */
3036 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3037 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3038 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3039 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3041 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3042 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3043 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3044 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3045 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3046 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3047 /* Analog input/passthru */
3048 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3049 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3050 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3051 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3052 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3060 static const char *alc880_models[ALC880_MODEL_LAST] = {
3061 [ALC880_3ST] = "3stack",
3062 [ALC880_TCL_S700] = "tcl",
3063 [ALC880_3ST_DIG] = "3stack-digout",
3064 [ALC880_CLEVO] = "clevo",
3065 [ALC880_5ST] = "5stack",
3066 [ALC880_5ST_DIG] = "5stack-digout",
3067 [ALC880_W810] = "w810",
3068 [ALC880_Z71V] = "z71v",
3069 [ALC880_6ST] = "6stack",
3070 [ALC880_6ST_DIG] = "6stack-digout",
3071 [ALC880_ASUS] = "asus",
3072 [ALC880_ASUS_W1V] = "asus-w1v",
3073 [ALC880_ASUS_DIG] = "asus-dig",
3074 [ALC880_ASUS_DIG2] = "asus-dig2",
3075 [ALC880_UNIWILL_DIG] = "uniwill",
3076 [ALC880_UNIWILL_P53] = "uniwill-p53",
3077 [ALC880_FUJITSU] = "fujitsu",
3078 [ALC880_F1734] = "F1734",
3080 [ALC880_LG_LW] = "lg-lw",
3081 [ALC880_MEDION_RIM] = "medion",
3082 #ifdef CONFIG_SND_DEBUG
3083 [ALC880_TEST] = "test",
3085 [ALC880_AUTO] = "auto",
3088 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3089 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3090 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3091 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3092 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3093 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3094 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3095 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3096 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3097 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3098 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3099 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3100 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3101 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3102 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3103 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3104 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3105 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3106 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3107 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3108 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3109 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3110 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3111 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3112 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3113 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3114 SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
3115 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3116 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3117 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3118 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3119 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3120 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3121 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3122 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3123 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3124 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3125 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3126 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3127 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3128 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3129 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3130 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3131 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3132 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3133 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3134 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3135 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3136 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3137 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3138 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3139 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3140 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3141 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3142 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3143 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3144 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3145 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3146 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3147 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3148 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3149 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3150 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3151 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3152 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3153 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3154 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3155 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3156 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3157 SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
3158 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3159 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3164 * ALC880 codec presets
3166 static struct alc_config_preset alc880_presets[] = {
3168 .mixers = { alc880_three_stack_mixer },
3169 .init_verbs = { alc880_volume_init_verbs,
3170 alc880_pin_3stack_init_verbs },
3171 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3172 .dac_nids = alc880_dac_nids,
3173 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3174 .channel_mode = alc880_threestack_modes,
3176 .input_mux = &alc880_capture_source,
3178 [ALC880_3ST_DIG] = {
3179 .mixers = { alc880_three_stack_mixer },
3180 .init_verbs = { alc880_volume_init_verbs,
3181 alc880_pin_3stack_init_verbs },
3182 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3183 .dac_nids = alc880_dac_nids,
3184 .dig_out_nid = ALC880_DIGOUT_NID,
3185 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3186 .channel_mode = alc880_threestack_modes,
3188 .input_mux = &alc880_capture_source,
3190 [ALC880_TCL_S700] = {
3191 .mixers = { alc880_tcl_s700_mixer },
3192 .init_verbs = { alc880_volume_init_verbs,
3193 alc880_pin_tcl_S700_init_verbs,
3194 alc880_gpio2_init_verbs },
3195 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3196 .dac_nids = alc880_dac_nids,
3198 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3199 .channel_mode = alc880_2_jack_modes,
3200 .input_mux = &alc880_capture_source,
3203 .mixers = { alc880_three_stack_mixer,
3204 alc880_five_stack_mixer},
3205 .init_verbs = { alc880_volume_init_verbs,
3206 alc880_pin_5stack_init_verbs },
3207 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3208 .dac_nids = alc880_dac_nids,
3209 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3210 .channel_mode = alc880_fivestack_modes,
3211 .input_mux = &alc880_capture_source,
3213 [ALC880_5ST_DIG] = {
3214 .mixers = { alc880_three_stack_mixer,
3215 alc880_five_stack_mixer },
3216 .init_verbs = { alc880_volume_init_verbs,
3217 alc880_pin_5stack_init_verbs },
3218 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3219 .dac_nids = alc880_dac_nids,
3220 .dig_out_nid = ALC880_DIGOUT_NID,
3221 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3222 .channel_mode = alc880_fivestack_modes,
3223 .input_mux = &alc880_capture_source,
3226 .mixers = { alc880_six_stack_mixer },
3227 .init_verbs = { alc880_volume_init_verbs,
3228 alc880_pin_6stack_init_verbs },
3229 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3230 .dac_nids = alc880_6st_dac_nids,
3231 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3232 .channel_mode = alc880_sixstack_modes,
3233 .input_mux = &alc880_6stack_capture_source,
3235 [ALC880_6ST_DIG] = {
3236 .mixers = { alc880_six_stack_mixer },
3237 .init_verbs = { alc880_volume_init_verbs,
3238 alc880_pin_6stack_init_verbs },
3239 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3240 .dac_nids = alc880_6st_dac_nids,
3241 .dig_out_nid = ALC880_DIGOUT_NID,
3242 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3243 .channel_mode = alc880_sixstack_modes,
3244 .input_mux = &alc880_6stack_capture_source,
3247 .mixers = { alc880_w810_base_mixer },
3248 .init_verbs = { alc880_volume_init_verbs,
3249 alc880_pin_w810_init_verbs,
3250 alc880_gpio2_init_verbs },
3251 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3252 .dac_nids = alc880_w810_dac_nids,
3253 .dig_out_nid = ALC880_DIGOUT_NID,
3254 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3255 .channel_mode = alc880_w810_modes,
3256 .input_mux = &alc880_capture_source,
3259 .mixers = { alc880_z71v_mixer },
3260 .init_verbs = { alc880_volume_init_verbs,
3261 alc880_pin_z71v_init_verbs },
3262 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3263 .dac_nids = alc880_z71v_dac_nids,
3264 .dig_out_nid = ALC880_DIGOUT_NID,
3266 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3267 .channel_mode = alc880_2_jack_modes,
3268 .input_mux = &alc880_capture_source,
3271 .mixers = { alc880_f1734_mixer },
3272 .init_verbs = { alc880_volume_init_verbs,
3273 alc880_pin_f1734_init_verbs },
3274 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3275 .dac_nids = alc880_f1734_dac_nids,
3277 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3278 .channel_mode = alc880_2_jack_modes,
3279 .input_mux = &alc880_f1734_capture_source,
3280 .unsol_event = alc880_uniwill_p53_unsol_event,
3281 .init_hook = alc880_uniwill_p53_hp_automute,
3284 .mixers = { alc880_asus_mixer },
3285 .init_verbs = { alc880_volume_init_verbs,
3286 alc880_pin_asus_init_verbs,
3287 alc880_gpio1_init_verbs },
3288 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3289 .dac_nids = alc880_asus_dac_nids,
3290 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3291 .channel_mode = alc880_asus_modes,
3293 .input_mux = &alc880_capture_source,
3295 [ALC880_ASUS_DIG] = {
3296 .mixers = { alc880_asus_mixer },
3297 .init_verbs = { alc880_volume_init_verbs,
3298 alc880_pin_asus_init_verbs,
3299 alc880_gpio1_init_verbs },
3300 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3301 .dac_nids = alc880_asus_dac_nids,
3302 .dig_out_nid = ALC880_DIGOUT_NID,
3303 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3304 .channel_mode = alc880_asus_modes,
3306 .input_mux = &alc880_capture_source,
3308 [ALC880_ASUS_DIG2] = {
3309 .mixers = { alc880_asus_mixer },
3310 .init_verbs = { alc880_volume_init_verbs,
3311 alc880_pin_asus_init_verbs,
3312 alc880_gpio2_init_verbs }, /* use GPIO2 */
3313 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3314 .dac_nids = alc880_asus_dac_nids,
3315 .dig_out_nid = ALC880_DIGOUT_NID,
3316 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3317 .channel_mode = alc880_asus_modes,
3319 .input_mux = &alc880_capture_source,
3321 [ALC880_ASUS_W1V] = {
3322 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3323 .init_verbs = { alc880_volume_init_verbs,
3324 alc880_pin_asus_init_verbs,
3325 alc880_gpio1_init_verbs },
3326 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3327 .dac_nids = alc880_asus_dac_nids,
3328 .dig_out_nid = ALC880_DIGOUT_NID,
3329 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3330 .channel_mode = alc880_asus_modes,
3332 .input_mux = &alc880_capture_source,
3334 [ALC880_UNIWILL_DIG] = {
3335 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3336 .init_verbs = { alc880_volume_init_verbs,
3337 alc880_pin_asus_init_verbs },
3338 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3339 .dac_nids = alc880_asus_dac_nids,
3340 .dig_out_nid = ALC880_DIGOUT_NID,
3341 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3342 .channel_mode = alc880_asus_modes,
3344 .input_mux = &alc880_capture_source,
3346 [ALC880_UNIWILL] = {
3347 .mixers = { alc880_uniwill_mixer },
3348 .init_verbs = { alc880_volume_init_verbs,
3349 alc880_uniwill_init_verbs },
3350 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3351 .dac_nids = alc880_asus_dac_nids,
3352 .dig_out_nid = ALC880_DIGOUT_NID,
3353 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3354 .channel_mode = alc880_threestack_modes,
3356 .input_mux = &alc880_capture_source,
3357 .unsol_event = alc880_uniwill_unsol_event,
3358 .init_hook = alc880_uniwill_automute,
3360 [ALC880_UNIWILL_P53] = {
3361 .mixers = { alc880_uniwill_p53_mixer },
3362 .init_verbs = { alc880_volume_init_verbs,
3363 alc880_uniwill_p53_init_verbs },
3364 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3365 .dac_nids = alc880_asus_dac_nids,
3366 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3367 .channel_mode = alc880_threestack_modes,
3368 .input_mux = &alc880_capture_source,
3369 .unsol_event = alc880_uniwill_p53_unsol_event,
3370 .init_hook = alc880_uniwill_p53_hp_automute,
3372 [ALC880_FUJITSU] = {
3373 .mixers = { alc880_fujitsu_mixer,
3374 alc880_pcbeep_mixer, },
3375 .init_verbs = { alc880_volume_init_verbs,
3376 alc880_uniwill_p53_init_verbs,
3377 alc880_beep_init_verbs },
3378 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3379 .dac_nids = alc880_dac_nids,
3380 .dig_out_nid = ALC880_DIGOUT_NID,
3381 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3382 .channel_mode = alc880_2_jack_modes,
3383 .input_mux = &alc880_capture_source,
3384 .unsol_event = alc880_uniwill_p53_unsol_event,
3385 .init_hook = alc880_uniwill_p53_hp_automute,
3388 .mixers = { alc880_three_stack_mixer },
3389 .init_verbs = { alc880_volume_init_verbs,
3390 alc880_pin_clevo_init_verbs },
3391 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3392 .dac_nids = alc880_dac_nids,
3394 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3395 .channel_mode = alc880_threestack_modes,
3397 .input_mux = &alc880_capture_source,
3400 .mixers = { alc880_lg_mixer },
3401 .init_verbs = { alc880_volume_init_verbs,
3402 alc880_lg_init_verbs },
3403 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3404 .dac_nids = alc880_lg_dac_nids,
3405 .dig_out_nid = ALC880_DIGOUT_NID,
3406 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3407 .channel_mode = alc880_lg_ch_modes,
3409 .input_mux = &alc880_lg_capture_source,
3410 .unsol_event = alc880_lg_unsol_event,
3411 .init_hook = alc880_lg_automute,
3412 #ifdef CONFIG_SND_HDA_POWER_SAVE
3413 .loopbacks = alc880_lg_loopbacks,
3417 .mixers = { alc880_lg_lw_mixer },
3418 .init_verbs = { alc880_volume_init_verbs,
3419 alc880_lg_lw_init_verbs },
3420 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3421 .dac_nids = alc880_dac_nids,
3422 .dig_out_nid = ALC880_DIGOUT_NID,
3423 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3424 .channel_mode = alc880_lg_lw_modes,
3425 .input_mux = &alc880_lg_lw_capture_source,
3426 .unsol_event = alc880_lg_lw_unsol_event,
3427 .init_hook = alc880_lg_lw_automute,
3429 [ALC880_MEDION_RIM] = {
3430 .mixers = { alc880_medion_rim_mixer },
3431 .init_verbs = { alc880_volume_init_verbs,
3432 alc880_medion_rim_init_verbs,
3433 alc_gpio2_init_verbs },
3434 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3435 .dac_nids = alc880_dac_nids,
3436 .dig_out_nid = ALC880_DIGOUT_NID,
3437 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3438 .channel_mode = alc880_2_jack_modes,
3439 .input_mux = &alc880_medion_rim_capture_source,
3440 .unsol_event = alc880_medion_rim_unsol_event,
3441 .init_hook = alc880_medion_rim_automute,
3443 #ifdef CONFIG_SND_DEBUG
3445 .mixers = { alc880_test_mixer },
3446 .init_verbs = { alc880_test_init_verbs },
3447 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3448 .dac_nids = alc880_test_dac_nids,
3449 .dig_out_nid = ALC880_DIGOUT_NID,
3450 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3451 .channel_mode = alc880_test_modes,
3452 .input_mux = &alc880_test_capture_source,
3458 * Automatic parse of I/O pins from the BIOS configuration
3461 #define NUM_CONTROL_ALLOC 32
3462 #define NUM_VERB_ALLOC 32
3466 ALC_CTL_WIDGET_MUTE,
3469 static struct snd_kcontrol_new alc880_control_templates[] = {
3470 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3471 HDA_CODEC_MUTE(NULL, 0, 0, 0),
3472 HDA_BIND_MUTE(NULL, 0, 0, 0),
3475 /* add dynamic controls */
3476 static int add_control(struct alc_spec *spec, int type, const char *name,
3479 struct snd_kcontrol_new *knew;
3481 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
3482 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
3484 /* array + terminator */
3485 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
3488 if (spec->kctl_alloc) {
3489 memcpy(knew, spec->kctl_alloc,
3490 sizeof(*knew) * spec->num_kctl_alloc);
3491 kfree(spec->kctl_alloc);
3493 spec->kctl_alloc = knew;
3494 spec->num_kctl_alloc = num;
3497 knew = &spec->kctl_alloc[spec->num_kctl_used];
3498 *knew = alc880_control_templates[type];
3499 knew->name = kstrdup(name, GFP_KERNEL);
3502 knew->private_value = val;
3503 spec->num_kctl_used++;
3507 #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17)
3508 #define alc880_fixed_pin_idx(nid) ((nid) - 0x14)
3509 #define alc880_is_multi_pin(nid) ((nid) >= 0x18)
3510 #define alc880_multi_pin_idx(nid) ((nid) - 0x18)
3511 #define alc880_is_input_pin(nid) ((nid) >= 0x18)
3512 #define alc880_input_pin_idx(nid) ((nid) - 0x18)
3513 #define alc880_idx_to_dac(nid) ((nid) + 0x02)
3514 #define alc880_dac_to_idx(nid) ((nid) - 0x02)
3515 #define alc880_idx_to_mixer(nid) ((nid) + 0x0c)
3516 #define alc880_idx_to_selector(nid) ((nid) + 0x10)
3517 #define ALC880_PIN_CD_NID 0x1c
3519 /* fill in the dac_nids table from the parsed pin configuration */
3520 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3521 const struct auto_pin_cfg *cfg)
3527 memset(assigned, 0, sizeof(assigned));
3528 spec->multiout.dac_nids = spec->private_dac_nids;
3530 /* check the pins hardwired to audio widget */
3531 for (i = 0; i < cfg->line_outs; i++) {
3532 nid = cfg->line_out_pins[i];
3533 if (alc880_is_fixed_pin(nid)) {
3534 int idx = alc880_fixed_pin_idx(nid);
3535 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3539 /* left pins can be connect to any audio widget */
3540 for (i = 0; i < cfg->line_outs; i++) {
3541 nid = cfg->line_out_pins[i];
3542 if (alc880_is_fixed_pin(nid))
3544 /* search for an empty channel */
3545 for (j = 0; j < cfg->line_outs; j++) {
3547 spec->multiout.dac_nids[i] =
3548 alc880_idx_to_dac(j);
3554 spec->multiout.num_dacs = cfg->line_outs;
3558 /* add playback controls from the parsed DAC table */
3559 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3560 const struct auto_pin_cfg *cfg)
3563 static const char *chname[4] = {
3564 "Front", "Surround", NULL /*CLFE*/, "Side"
3569 for (i = 0; i < cfg->line_outs; i++) {
3570 if (!spec->multiout.dac_nids[i])
3572 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3575 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3576 "Center Playback Volume",
3577 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3581 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3582 "LFE Playback Volume",
3583 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
3587 err = add_control(spec, ALC_CTL_BIND_MUTE,
3588 "Center Playback Switch",
3589 HDA_COMPOSE_AMP_VAL(nid, 1, 2,
3593 err = add_control(spec, ALC_CTL_BIND_MUTE,
3594 "LFE Playback Switch",
3595 HDA_COMPOSE_AMP_VAL(nid, 2, 2,
3600 sprintf(name, "%s Playback Volume", chname[i]);
3601 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3602 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3606 sprintf(name, "%s Playback Switch", chname[i]);
3607 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3608 HDA_COMPOSE_AMP_VAL(nid, 3, 2,
3617 /* add playback controls for speaker and HP outputs */
3618 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
3628 if (alc880_is_fixed_pin(pin)) {
3629 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
3630 /* specify the DAC as the extra output */
3631 if (!spec->multiout.hp_nid)
3632 spec->multiout.hp_nid = nid;
3634 spec->multiout.extra_out_nid[0] = nid;
3635 /* control HP volume/switch on the output mixer amp */
3636 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
3637 sprintf(name, "%s Playback Volume", pfx);
3638 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3639 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3642 sprintf(name, "%s Playback Switch", pfx);
3643 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3644 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
3647 } else if (alc880_is_multi_pin(pin)) {
3648 /* set manual connection */
3649 /* we have only a switch on HP-out PIN */
3650 sprintf(name, "%s Playback Switch", pfx);
3651 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3652 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3659 /* create input playback/capture controls for the given pin */
3660 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
3661 const char *ctlname,
3662 int idx, hda_nid_t mix_nid)
3667 sprintf(name, "%s Playback Volume", ctlname);
3668 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3669 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3672 sprintf(name, "%s Playback Switch", ctlname);
3673 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3674 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3680 /* create playback/capture controls for input pins */
3681 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3682 const struct auto_pin_cfg *cfg)
3684 struct hda_input_mux *imux = &spec->private_imux;
3687 for (i = 0; i < AUTO_PIN_LAST; i++) {
3688 if (alc880_is_input_pin(cfg->input_pins[i])) {
3689 idx = alc880_input_pin_idx(cfg->input_pins[i]);
3690 err = new_analog_input(spec, cfg->input_pins[i],
3691 auto_pin_cfg_labels[i],
3695 imux->items[imux->num_items].label =
3696 auto_pin_cfg_labels[i];
3697 imux->items[imux->num_items].index =
3698 alc880_input_pin_idx(cfg->input_pins[i]);
3705 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
3706 unsigned int pin_type)
3708 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3711 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3715 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3716 hda_nid_t nid, int pin_type,
3719 alc_set_pin_output(codec, nid, pin_type);
3720 /* need the manual connection? */
3721 if (alc880_is_multi_pin(nid)) {
3722 struct alc_spec *spec = codec->spec;
3723 int idx = alc880_multi_pin_idx(nid);
3724 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3725 AC_VERB_SET_CONNECT_SEL,
3726 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3730 static int get_pin_type(int line_out_type)
3732 if (line_out_type == AUTO_PIN_HP_OUT)
3738 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3740 struct alc_spec *spec = codec->spec;
3743 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3744 for (i = 0; i < spec->autocfg.line_outs; i++) {
3745 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3746 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3747 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
3751 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3753 struct alc_spec *spec = codec->spec;
3756 pin = spec->autocfg.speaker_pins[0];
3757 if (pin) /* connect to front */
3758 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3759 pin = spec->autocfg.hp_pins[0];
3760 if (pin) /* connect to front */
3761 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3764 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3766 struct alc_spec *spec = codec->spec;
3769 for (i = 0; i < AUTO_PIN_LAST; i++) {
3770 hda_nid_t nid = spec->autocfg.input_pins[i];
3771 if (alc880_is_input_pin(nid)) {
3772 snd_hda_codec_write(codec, nid, 0,
3773 AC_VERB_SET_PIN_WIDGET_CONTROL,
3774 i <= AUTO_PIN_FRONT_MIC ?
3775 PIN_VREF80 : PIN_IN);
3776 if (nid != ALC880_PIN_CD_NID)
3777 snd_hda_codec_write(codec, nid, 0,
3778 AC_VERB_SET_AMP_GAIN_MUTE,
3784 /* parse the BIOS configuration and set up the alc_spec */
3785 /* return 1 if successful, 0 if the proper config is not found,
3786 * or a negative error code
3788 static int alc880_parse_auto_config(struct hda_codec *codec)
3790 struct alc_spec *spec = codec->spec;
3792 static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3794 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3798 if (!spec->autocfg.line_outs)
3799 return 0; /* can't find valid BIOS pin config */
3801 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
3804 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
3807 err = alc880_auto_create_extra_out(spec,
3808 spec->autocfg.speaker_pins[0],
3812 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3816 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
3820 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3822 if (spec->autocfg.dig_out_pin)
3823 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3824 if (spec->autocfg.dig_in_pin)
3825 spec->dig_in_nid = ALC880_DIGIN_NID;
3827 if (spec->kctl_alloc)
3828 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3830 spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3832 spec->num_mux_defs = 1;
3833 spec->input_mux = &spec->private_imux;
3838 /* additional initialization for auto-configuration model */
3839 static void alc880_auto_init(struct hda_codec *codec)
3841 struct alc_spec *spec = codec->spec;
3842 alc880_auto_init_multi_out(codec);
3843 alc880_auto_init_extra_out(codec);
3844 alc880_auto_init_analog_input(codec);
3845 if (spec->unsol_event)
3846 alc_inithook(codec);
3850 * OK, here we have finally the patch for ALC880
3853 static int patch_alc880(struct hda_codec *codec)
3855 struct alc_spec *spec;
3859 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3865 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3868 if (board_config < 0) {
3869 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3870 "trying auto-probe from BIOS...\n");
3871 board_config = ALC880_AUTO;
3874 if (board_config == ALC880_AUTO) {
3875 /* automatic parse from the BIOS config */
3876 err = alc880_parse_auto_config(codec);
3882 "hda_codec: Cannot set up configuration "
3883 "from BIOS. Using 3-stack mode...\n");
3884 board_config = ALC880_3ST;
3888 if (board_config != ALC880_AUTO)
3889 setup_preset(spec, &alc880_presets[board_config]);
3891 spec->stream_name_analog = "ALC880 Analog";
3892 spec->stream_analog_playback = &alc880_pcm_analog_playback;
3893 spec->stream_analog_capture = &alc880_pcm_analog_capture;
3894 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
3896 spec->stream_name_digital = "ALC880 Digital";
3897 spec->stream_digital_playback = &alc880_pcm_digital_playback;
3898 spec->stream_digital_capture = &alc880_pcm_digital_capture;
3900 if (!spec->adc_nids && spec->input_mux) {
3901 /* check whether NID 0x07 is valid */
3902 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3904 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3905 if (wcap != AC_WID_AUD_IN) {
3906 spec->adc_nids = alc880_adc_nids_alt;
3907 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3908 spec->mixers[spec->num_mixers] =
3909 alc880_capture_alt_mixer;
3912 spec->adc_nids = alc880_adc_nids;
3913 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3914 spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3919 spec->vmaster_nid = 0x0c;
3921 codec->patch_ops = alc_patch_ops;
3922 if (board_config == ALC880_AUTO)
3923 spec->init_hook = alc880_auto_init;
3924 #ifdef CONFIG_SND_HDA_POWER_SAVE
3925 if (!spec->loopback.amplist)
3926 spec->loopback.amplist = alc880_loopbacks;
3937 static hda_nid_t alc260_dac_nids[1] = {
3942 static hda_nid_t alc260_adc_nids[1] = {
3947 static hda_nid_t alc260_adc_nids_alt[1] = {
3952 static hda_nid_t alc260_hp_adc_nids[2] = {
3957 /* NIDs used when simultaneous access to both ADCs makes sense. Note that
3958 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
3960 static hda_nid_t alc260_dual_adc_nids[2] = {
3965 #define ALC260_DIGOUT_NID 0x03
3966 #define ALC260_DIGIN_NID 0x06
3968 static struct hda_input_mux alc260_capture_source = {
3972 { "Front Mic", 0x1 },
3978 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
3979 * headphone jack and the internal CD lines since these are the only pins at
3980 * which audio can appear. For flexibility, also allow the option of
3981 * recording the mixer output on the second ADC (ADC0 doesn't have a
3982 * connection to the mixer output).
3984 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
3988 { "Mic/Line", 0x0 },
3990 { "Headphone", 0x2 },
3996 { "Mic/Line", 0x0 },
3998 { "Headphone", 0x2 },
4005 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4006 * the Fujitsu S702x, but jacks are marked differently.
4008 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4015 { "Headphone", 0x5 },
4024 { "Headphone", 0x6 },
4030 * This is just place-holder, so there's something for alc_build_pcms to look
4031 * at when it calculates the maximum number of channels. ALC260 has no mixer
4032 * element which allows changing the channel mode, so the verb list is
4035 static struct hda_channel_mode alc260_modes[1] = {
4040 /* Mixer combinations
4042 * basic: base_output + input + pc_beep + capture
4043 * HP: base_output + input + capture_alt
4044 * HP_3013: hp_3013 + input + capture
4045 * fujitsu: fujitsu + capture
4046 * acer: acer + capture
4049 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4050 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4051 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4052 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4053 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4054 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4055 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4059 static struct snd_kcontrol_new alc260_input_mixer[] = {
4060 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4061 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4062 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4063 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4064 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4065 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4066 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4067 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4071 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
4072 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
4073 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
4077 /* update HP, line and mono out pins according to the master switch */
4078 static void alc260_hp_master_update(struct hda_codec *codec,
4079 hda_nid_t hp, hda_nid_t line,
4082 struct alc_spec *spec = codec->spec;
4083 unsigned int val = spec->master_sw ? PIN_HP : 0;
4084 /* change HP and line-out pins */
4085 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4087 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4089 /* mono (speaker) depending on the HP jack sense */
4090 val = (val && !spec->jack_present) ? PIN_OUT : 0;
4091 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4095 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4096 struct snd_ctl_elem_value *ucontrol)
4098 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4099 struct alc_spec *spec = codec->spec;
4100 *ucontrol->value.integer.value = spec->master_sw;
4104 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4105 struct snd_ctl_elem_value *ucontrol)
4107 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4108 struct alc_spec *spec = codec->spec;
4109 int val = !!*ucontrol->value.integer.value;
4110 hda_nid_t hp, line, mono;
4112 if (val == spec->master_sw)
4114 spec->master_sw = val;
4115 hp = (kcontrol->private_value >> 16) & 0xff;
4116 line = (kcontrol->private_value >> 8) & 0xff;
4117 mono = kcontrol->private_value & 0xff;
4118 alc260_hp_master_update(codec, hp, line, mono);
4122 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4124 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4125 .name = "Master Playback Switch",
4126 .info = snd_ctl_boolean_mono_info,
4127 .get = alc260_hp_master_sw_get,
4128 .put = alc260_hp_master_sw_put,
4129 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4131 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4132 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4133 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4134 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4135 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4137 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4141 static struct hda_verb alc260_hp_unsol_verbs[] = {
4142 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4146 static void alc260_hp_automute(struct hda_codec *codec)
4148 struct alc_spec *spec = codec->spec;
4149 unsigned int present;
4151 present = snd_hda_codec_read(codec, 0x10, 0,
4152 AC_VERB_GET_PIN_SENSE, 0);
4153 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4154 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4157 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4159 if ((res >> 26) == ALC880_HP_EVENT)
4160 alc260_hp_automute(codec);
4163 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4165 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4166 .name = "Master Playback Switch",
4167 .info = snd_ctl_boolean_mono_info,
4168 .get = alc260_hp_master_sw_get,
4169 .put = alc260_hp_master_sw_put,
4170 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
4172 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4173 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4174 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4175 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4176 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4177 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4178 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4179 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4183 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4184 .ops = &snd_hda_bind_vol,
4186 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4187 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4188 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4193 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4194 .ops = &snd_hda_bind_sw,
4196 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4197 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4202 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4203 HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4204 HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4205 HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4206 HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4210 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4211 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4215 static void alc260_hp_3013_automute(struct hda_codec *codec)
4217 struct alc_spec *spec = codec->spec;
4218 unsigned int present;
4220 present = snd_hda_codec_read(codec, 0x15, 0,
4221 AC_VERB_GET_PIN_SENSE, 0);
4222 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4223 alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
4226 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4229 if ((res >> 26) == ALC880_HP_EVENT)
4230 alc260_hp_3013_automute(codec);
4233 static void alc260_hp_3012_automute(struct hda_codec *codec)
4235 unsigned int present, bits;
4237 present = snd_hda_codec_read(codec, 0x10, 0,
4238 AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4240 bits = present ? 0 : PIN_OUT;
4241 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4243 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4245 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4249 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4252 if ((res >> 26) == ALC880_HP_EVENT)
4253 alc260_hp_3012_automute(codec);
4256 /* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12,
4257 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10.
4259 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4260 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4261 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4262 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4263 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4264 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4265 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4266 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4267 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4268 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4269 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4270 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4271 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4275 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current
4276 * versions of the ALC260 don't act on requests to enable mic bias from NID
4277 * 0x0f (used to drive the headphone jack in these laptops). The ALC260
4278 * datasheet doesn't mention this restriction. At this stage it's not clear
4279 * whether this behaviour is intentional or is a hardware bug in chip
4280 * revisions available in early 2006. Therefore for now allow the
4281 * "Headphone Jack Mode" control to span all choices, but if it turns out
4282 * that the lack of mic bias for this NID is intentional we could change the
4283 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4285 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4286 * don't appear to make the mic bias available from the "line" jack, even
4287 * though the NID used for this jack (0x14) can supply it. The theory is
4288 * that perhaps Acer have included blocking capacitors between the ALC260
4289 * and the output jack. If this turns out to be the case for all such
4290 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4291 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4293 * The C20x Tablet series have a mono internal speaker which is controlled
4294 * via the chip's Mono sum widget and pin complex, so include the necessary
4295 * controls for such models. On models without a "mono speaker" the control
4296 * won't do anything.
4298 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4299 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4300 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4301 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4302 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4304 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4306 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4307 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4308 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4309 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4310 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4311 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4312 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4313 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4314 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4315 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4319 /* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4320 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17.
4322 static struct snd_kcontrol_new alc260_will_mixer[] = {
4323 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4324 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4325 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4326 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4327 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4328 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4329 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4330 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4331 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4332 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4333 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4334 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4338 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4339 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4341 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4342 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4343 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4344 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4345 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4346 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4347 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4348 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4349 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4350 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4351 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4355 /* capture mixer elements */
4356 static struct snd_kcontrol_new alc260_capture_mixer[] = {
4357 HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
4358 HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
4359 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
4360 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
4362 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4363 /* The multiple "Capture Source" controls confuse alsamixer
4364 * So call somewhat different..
4366 /* .name = "Capture Source", */
4367 .name = "Input Source",
4369 .info = alc_mux_enum_info,
4370 .get = alc_mux_enum_get,
4371 .put = alc_mux_enum_put,
4376 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
4377 HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
4378 HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
4380 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4381 /* The multiple "Capture Source" controls confuse alsamixer
4382 * So call somewhat different..
4384 /* .name = "Capture Source", */
4385 .name = "Input Source",
4387 .info = alc_mux_enum_info,
4388 .get = alc_mux_enum_get,
4389 .put = alc_mux_enum_put,
4395 * initialization verbs
4397 static struct hda_verb alc260_init_verbs[] = {
4398 /* Line In pin widget for input */
4399 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4400 /* CD pin widget for input */
4401 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4402 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4403 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4404 /* Mic2 (front panel) pin widget for input and vref at 80% */
4405 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4406 /* LINE-2 is used for line-out in rear */
4407 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4408 /* select line-out */
4409 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4411 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4413 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4415 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4416 /* mute capture amp left and right */
4417 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4418 /* set connection select to line in (default select for this ADC) */
4419 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4420 /* mute capture amp left and right */
4421 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4422 /* set connection select to line in (default select for this ADC) */
4423 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4424 /* set vol=0 Line-Out mixer amp left and right */
4425 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4426 /* unmute pin widget amp left and right (no gain on this amp) */
4427 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4428 /* set vol=0 HP mixer amp left and right */
4429 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4430 /* unmute pin widget amp left and right (no gain on this amp) */
4431 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4432 /* set vol=0 Mono mixer amp left and right */
4433 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4434 /* unmute pin widget amp left and right (no gain on this amp) */
4435 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4436 /* unmute LINE-2 out pin */
4437 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4438 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4441 /* mute analog inputs */
4442 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4443 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4444 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4445 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4446 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4447 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4448 /* mute Front out path */
4449 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4450 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4451 /* mute Headphone out path */
4452 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4453 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4454 /* mute Mono out path */
4455 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4456 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4460 #if 0 /* should be identical with alc260_init_verbs? */
4461 static struct hda_verb alc260_hp_init_verbs[] = {
4462 /* Headphone and output */
4463 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4465 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4466 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4467 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4468 /* Mic2 (front panel) pin widget for input and vref at 80% */
4469 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4470 /* Line In pin widget for input */
4471 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4472 /* Line-2 pin widget for output */
4473 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4474 /* CD pin widget for input */
4475 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4476 /* unmute amp left and right */
4477 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4478 /* set connection select to line in (default select for this ADC) */
4479 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4480 /* unmute Line-Out mixer amp left and right (volume = 0) */
4481 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4482 /* mute pin widget amp left and right (no gain on this amp) */
4483 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4484 /* unmute HP mixer amp left and right (volume = 0) */
4485 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4486 /* mute pin widget amp left and right (no gain on this amp) */
4487 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4488 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4491 /* mute analog inputs */
4492 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4493 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4494 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4495 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4496 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4497 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4498 /* Unmute Front out path */
4499 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4500 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4501 /* Unmute Headphone out path */
4502 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4503 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4504 /* Unmute Mono out path */
4505 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4506 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4511 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4512 /* Line out and output */
4513 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4515 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4516 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4517 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4518 /* Mic2 (front panel) pin widget for input and vref at 80% */
4519 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4520 /* Line In pin widget for input */
4521 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4522 /* Headphone pin widget for output */
4523 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4524 /* CD pin widget for input */
4525 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4526 /* unmute amp left and right */
4527 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4528 /* set connection select to line in (default select for this ADC) */
4529 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4530 /* unmute Line-Out mixer amp left and right (volume = 0) */
4531 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4532 /* mute pin widget amp left and right (no gain on this amp) */
4533 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4534 /* unmute HP mixer amp left and right (volume = 0) */
4535 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4536 /* mute pin widget amp left and right (no gain on this amp) */
4537 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4538 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4541 /* mute analog inputs */
4542 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4543 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4544 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4545 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4546 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4547 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4548 /* Unmute Front out path */
4549 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4550 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4551 /* Unmute Headphone out path */
4552 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4553 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4554 /* Unmute Mono out path */
4555 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4556 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4560 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4561 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4562 * audio = 0x16, internal speaker = 0x10.
4564 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4565 /* Disable all GPIOs */
4566 {0x01, AC_VERB_SET_GPIO_MASK, 0},
4567 /* Internal speaker is connected to headphone pin */
4568 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4569 /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4570 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4571 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4572 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4573 /* Ensure all other unused pins are disabled and muted. */
4574 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4575 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4576 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4577 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4578 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4579 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4580 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4581 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4583 /* Disable digital (SPDIF) pins */
4584 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4585 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4587 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4588 * when acting as an output.
4590 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4592 /* Start with output sum widgets muted and their output gains at min */
4593 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4594 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4595 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4596 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4597 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4598 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4599 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4600 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4601 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4603 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4604 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4605 /* Unmute Line1 pin widget output buffer since it starts as an output.
4606 * If the pin mode is changed by the user the pin mode control will
4607 * take care of enabling the pin's input/output buffers as needed.
4608 * Therefore there's no need to enable the input buffer at this
4611 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4612 /* Unmute input buffer of pin widget used for Line-in (no equiv
4615 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4617 /* Mute capture amp left and right */
4618 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4619 /* Set ADC connection select to match default mixer setting - line
4622 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4624 /* Do the same for the second ADC: mute capture input amp and
4625 * set ADC connection to line in (on mic1 pin)
4627 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4628 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4630 /* Mute all inputs to mixer widget (even unconnected ones) */
4631 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4632 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4633 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4634 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4635 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4636 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4637 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4638 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4643 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
4644 * similar laptops (adapted from Fujitsu init verbs).
4646 static struct hda_verb alc260_acer_init_verbs[] = {
4647 /* On TravelMate laptops, GPIO 0 enables the internal speaker and
4648 * the headphone jack. Turn this on and rely on the standard mute
4649 * methods whenever the user wants to turn these outputs off.
4651 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4652 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4653 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4654 /* Internal speaker/Headphone jack is connected to Line-out pin */
4655 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4656 /* Internal microphone/Mic jack is connected to Mic1 pin */
4657 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
4658 /* Line In jack is connected to Line1 pin */
4659 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4660 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
4661 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4662 /* Ensure all other unused pins are disabled and muted. */
4663 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4664 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4665 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4666 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4667 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4668 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4669 /* Disable digital (SPDIF) pins */
4670 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4671 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4673 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
4674 * bus when acting as outputs.
4676 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4677 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4679 /* Start with output sum widgets muted and their output gains at min */
4680 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4681 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4682 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4683 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4684 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4685 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4686 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4687 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4688 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4690 /* Unmute Line-out pin widget amp left and right
4691 * (no equiv mixer ctrl)
4693 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4694 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
4695 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4696 /* Unmute Mic1 and Line1 pin widget input buffers since they start as
4697 * inputs. If the pin mode is changed by the user the pin mode control
4698 * will take care of enabling the pin's input/output buffers as needed.
4699 * Therefore there's no need to enable the input buffer at this
4702 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4703 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4705 /* Mute capture amp left and right */
4706 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4707 /* Set ADC connection select to match default mixer setting - mic
4710 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4712 /* Do similar with the second ADC: mute capture input amp and
4713 * set ADC connection to mic to match ALSA's default state.
4715 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4716 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4718 /* Mute all inputs to mixer widget (even unconnected ones) */
4719 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4720 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4721 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4722 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4723 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4724 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4725 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4726 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4731 static struct hda_verb alc260_will_verbs[] = {
4732 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4733 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
4734 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
4735 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4736 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4737 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
4741 static struct hda_verb alc260_replacer_672v_verbs[] = {
4742 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4743 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4744 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
4746 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4747 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4748 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4750 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4754 /* toggle speaker-output according to the hp-jack state */
4755 static void alc260_replacer_672v_automute(struct hda_codec *codec)
4757 unsigned int present;
4759 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
4760 present = snd_hda_codec_read(codec, 0x0f, 0,
4761 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
4763 snd_hda_codec_write_cache(codec, 0x01, 0,
4764 AC_VERB_SET_GPIO_DATA, 1);
4765 snd_hda_codec_write_cache(codec, 0x0f, 0,
4766 AC_VERB_SET_PIN_WIDGET_CONTROL,
4769 snd_hda_codec_write_cache(codec, 0x01, 0,
4770 AC_VERB_SET_GPIO_DATA, 0);
4771 snd_hda_codec_write_cache(codec, 0x0f, 0,
4772 AC_VERB_SET_PIN_WIDGET_CONTROL,
4777 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
4780 if ((res >> 26) == ALC880_HP_EVENT)
4781 alc260_replacer_672v_automute(codec);
4784 static struct hda_verb alc260_hp_dc7600_verbs[] = {
4785 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
4786 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4787 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4788 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4789 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4790 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4791 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4792 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4793 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4794 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4798 /* Test configuration for debugging, modelled after the ALC880 test
4801 #ifdef CONFIG_SND_DEBUG
4802 static hda_nid_t alc260_test_dac_nids[1] = {
4805 static hda_nid_t alc260_test_adc_nids[2] = {
4808 /* For testing the ALC260, each input MUX needs its own definition since
4809 * the signal assignments are different. This assumes that the first ADC
4812 static struct hda_input_mux alc260_test_capture_sources[2] = {
4816 { "MIC1 pin", 0x0 },
4817 { "MIC2 pin", 0x1 },
4818 { "LINE1 pin", 0x2 },
4819 { "LINE2 pin", 0x3 },
4821 { "LINE-OUT pin", 0x5 },
4822 { "HP-OUT pin", 0x6 },
4828 { "MIC1 pin", 0x0 },
4829 { "MIC2 pin", 0x1 },
4830 { "LINE1 pin", 0x2 },
4831 { "LINE2 pin", 0x3 },
4834 { "LINE-OUT pin", 0x6 },
4835 { "HP-OUT pin", 0x7 },
4839 static struct snd_kcontrol_new alc260_test_mixer[] = {
4840 /* Output driver widgets */
4841 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4842 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4843 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4844 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
4845 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4846 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
4848 /* Modes for retasking pin widgets
4849 * Note: the ALC260 doesn't seem to act on requests to enable mic
4850 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't
4851 * mention this restriction. At this stage it's not clear whether
4852 * this behaviour is intentional or is a hardware bug in chip
4853 * revisions available at least up until early 2006. Therefore for
4854 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
4855 * choices, but if it turns out that the lack of mic bias for these
4856 * NIDs is intentional we could change their modes from
4857 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4859 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
4860 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
4861 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
4862 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
4863 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
4864 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
4866 /* Loopback mixer controls */
4867 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
4868 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
4869 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
4870 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
4871 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
4872 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
4873 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
4874 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
4875 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4876 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4877 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4878 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4879 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
4880 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
4881 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
4882 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
4884 /* Controls for GPIO pins, assuming they are configured as outputs */
4885 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
4886 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
4887 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
4888 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
4890 /* Switches to allow the digital IO pins to be enabled. The datasheet
4891 * is ambigious as to which NID is which; testing on laptops which
4892 * make this output available should provide clarification.
4894 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
4895 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
4897 /* A switch allowing EAPD to be enabled. Some laptops seem to use
4898 * this output to turn on an external amplifier.
4900 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
4901 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
4905 static struct hda_verb alc260_test_init_verbs[] = {
4906 /* Enable all GPIOs as outputs with an initial value of 0 */
4907 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
4908 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4909 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
4911 /* Enable retasking pins as output, initially without power amp */
4912 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4913 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4914 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4915 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4916 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4917 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4919 /* Disable digital (SPDIF) pins initially, but users can enable
4920 * them via a mixer switch. In the case of SPDIF-out, this initverb
4921 * payload also sets the generation to 0, output to be in "consumer"
4922 * PCM format, copyright asserted, no pre-emphasis and no validity
4925 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4926 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4928 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
4929 * OUT1 sum bus when acting as an output.
4931 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4932 {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
4933 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4934 {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
4936 /* Start with output sum widgets muted and their output gains at min */
4937 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4938 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4939 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4940 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4941 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4942 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4943 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4944 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4945 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4947 /* Unmute retasking pin widget output buffers since the default
4948 * state appears to be output. As the pin mode is changed by the
4949 * user the pin mode control will take care of enabling the pin's
4950 * input/output buffers as needed.
4952 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4953 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4954 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4955 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4956 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4957 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4958 /* Also unmute the mono-out pin widget */
4959 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4961 /* Mute capture amp left and right */
4962 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4963 /* Set ADC connection select to match default mixer setting (mic1
4966 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4968 /* Do the same for the second ADC: mute capture input amp and
4969 * set ADC connection to mic1 pin
4971 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4972 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4974 /* Mute all inputs to mixer widget (even unconnected ones) */
4975 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4976 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4977 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4978 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4979 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4980 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4981 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4982 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4988 #define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback
4989 #define alc260_pcm_analog_capture alc880_pcm_analog_capture
4991 #define alc260_pcm_digital_playback alc880_pcm_digital_playback
4992 #define alc260_pcm_digital_capture alc880_pcm_digital_capture
4995 * for BIOS auto-configuration
4998 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5002 unsigned long vol_val, sw_val;
5006 if (nid >= 0x0f && nid < 0x11) {
5007 nid_vol = nid - 0x7;
5008 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5009 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5010 } else if (nid == 0x11) {
5011 nid_vol = nid - 0x7;
5012 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5013 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5014 } else if (nid >= 0x12 && nid <= 0x15) {
5016 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5017 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5021 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5022 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5025 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5026 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5032 /* add playback controls from the parsed DAC table */
5033 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5034 const struct auto_pin_cfg *cfg)
5039 spec->multiout.num_dacs = 1;
5040 spec->multiout.dac_nids = spec->private_dac_nids;
5041 spec->multiout.dac_nids[0] = 0x02;
5043 nid = cfg->line_out_pins[0];
5045 err = alc260_add_playback_controls(spec, nid, "Front");
5050 nid = cfg->speaker_pins[0];
5052 err = alc260_add_playback_controls(spec, nid, "Speaker");
5057 nid = cfg->hp_pins[0];
5059 err = alc260_add_playback_controls(spec, nid, "Headphone");
5066 /* create playback/capture controls for input pins */
5067 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5068 const struct auto_pin_cfg *cfg)
5070 struct hda_input_mux *imux = &spec->private_imux;
5073 for (i = 0; i < AUTO_PIN_LAST; i++) {
5074 if (cfg->input_pins[i] >= 0x12) {
5075 idx = cfg->input_pins[i] - 0x12;
5076 err = new_analog_input(spec, cfg->input_pins[i],
5077 auto_pin_cfg_labels[i], idx,
5081 imux->items[imux->num_items].label =
5082 auto_pin_cfg_labels[i];
5083 imux->items[imux->num_items].index = idx;
5086 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5087 idx = cfg->input_pins[i] - 0x09;
5088 err = new_analog_input(spec, cfg->input_pins[i],
5089 auto_pin_cfg_labels[i], idx,
5093 imux->items[imux->num_items].label =
5094 auto_pin_cfg_labels[i];
5095 imux->items[imux->num_items].index = idx;
5102 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5103 hda_nid_t nid, int pin_type,
5106 alc_set_pin_output(codec, nid, pin_type);
5107 /* need the manual connection? */
5109 int idx = nid - 0x12;
5110 snd_hda_codec_write(codec, idx + 0x0b, 0,
5111 AC_VERB_SET_CONNECT_SEL, sel_idx);
5115 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5117 struct alc_spec *spec = codec->spec;
5120 alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5121 nid = spec->autocfg.line_out_pins[0];
5123 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5124 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5127 nid = spec->autocfg.speaker_pins[0];
5129 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5131 nid = spec->autocfg.hp_pins[0];
5133 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5136 #define ALC260_PIN_CD_NID 0x16
5137 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5139 struct alc_spec *spec = codec->spec;
5142 for (i = 0; i < AUTO_PIN_LAST; i++) {
5143 hda_nid_t nid = spec->autocfg.input_pins[i];
5145 snd_hda_codec_write(codec, nid, 0,
5146 AC_VERB_SET_PIN_WIDGET_CONTROL,
5147 i <= AUTO_PIN_FRONT_MIC ?
5148 PIN_VREF80 : PIN_IN);
5149 if (nid != ALC260_PIN_CD_NID)
5150 snd_hda_codec_write(codec, nid, 0,
5151 AC_VERB_SET_AMP_GAIN_MUTE,
5158 * generic initialization of ADC, input mixers and output mixers
5160 static struct hda_verb alc260_volume_init_verbs[] = {
5162 * Unmute ADC0-1 and set the default input to mic-in
5164 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5165 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5166 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5167 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5169 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5171 * Note: PASD motherboards uses the Line In 2 as the input for
5172 * front panel mic (mic 2)
5174 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5175 /* mute analog inputs */
5176 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5177 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5178 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5179 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5180 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5183 * Set up output mixers (0x08 - 0x0a)
5185 /* set vol=0 to output mixers */
5186 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5187 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5188 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5189 /* set up input amps for analog loopback */
5190 /* Amp Indices: DAC = 0, mixer = 1 */
5191 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5192 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5193 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5194 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5195 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5196 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5201 static int alc260_parse_auto_config(struct hda_codec *codec)
5203 struct alc_spec *spec = codec->spec;
5206 static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5208 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5212 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5215 if (!spec->kctl_alloc)
5216 return 0; /* can't find valid BIOS pin config */
5217 err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5221 spec->multiout.max_channels = 2;
5223 if (spec->autocfg.dig_out_pin)
5224 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5225 if (spec->kctl_alloc)
5226 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5228 spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
5230 spec->num_mux_defs = 1;
5231 spec->input_mux = &spec->private_imux;
5233 /* check whether NID 0x04 is valid */
5234 wcap = get_wcaps(codec, 0x04);
5235 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5236 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5237 spec->adc_nids = alc260_adc_nids_alt;
5238 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5239 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
5241 spec->adc_nids = alc260_adc_nids;
5242 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5243 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
5250 /* additional initialization for auto-configuration model */
5251 static void alc260_auto_init(struct hda_codec *codec)
5253 struct alc_spec *spec = codec->spec;
5254 alc260_auto_init_multi_out(codec);
5255 alc260_auto_init_analog_input(codec);
5256 if (spec->unsol_event)
5257 alc_inithook(codec);
5260 #ifdef CONFIG_SND_HDA_POWER_SAVE
5261 static struct hda_amp_list alc260_loopbacks[] = {
5262 { 0x07, HDA_INPUT, 0 },
5263 { 0x07, HDA_INPUT, 1 },
5264 { 0x07, HDA_INPUT, 2 },
5265 { 0x07, HDA_INPUT, 3 },
5266 { 0x07, HDA_INPUT, 4 },
5272 * ALC260 configurations
5274 static const char *alc260_models[ALC260_MODEL_LAST] = {
5275 [ALC260_BASIC] = "basic",
5277 [ALC260_HP_3013] = "hp-3013",
5278 [ALC260_HP_DC7600] = "hp-dc7600",
5279 [ALC260_FUJITSU_S702X] = "fujitsu",
5280 [ALC260_ACER] = "acer",
5281 [ALC260_WILL] = "will",
5282 [ALC260_REPLACER_672V] = "replacer",
5283 #ifdef CONFIG_SND_DEBUG
5284 [ALC260_TEST] = "test",
5286 [ALC260_AUTO] = "auto",
5289 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5290 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5291 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5292 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5293 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5294 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5295 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5296 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5297 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5298 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5299 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5300 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5301 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5302 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5303 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5304 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5305 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5306 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5307 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5311 static struct alc_config_preset alc260_presets[] = {
5313 .mixers = { alc260_base_output_mixer,
5315 alc260_pc_beep_mixer,
5316 alc260_capture_mixer },
5317 .init_verbs = { alc260_init_verbs },
5318 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5319 .dac_nids = alc260_dac_nids,
5320 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5321 .adc_nids = alc260_adc_nids,
5322 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5323 .channel_mode = alc260_modes,
5324 .input_mux = &alc260_capture_source,
5327 .mixers = { alc260_hp_output_mixer,
5329 alc260_capture_alt_mixer },
5330 .init_verbs = { alc260_init_verbs,
5331 alc260_hp_unsol_verbs },
5332 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5333 .dac_nids = alc260_dac_nids,
5334 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5335 .adc_nids = alc260_hp_adc_nids,
5336 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5337 .channel_mode = alc260_modes,
5338 .input_mux = &alc260_capture_source,
5339 .unsol_event = alc260_hp_unsol_event,
5340 .init_hook = alc260_hp_automute,
5342 [ALC260_HP_DC7600] = {
5343 .mixers = { alc260_hp_dc7600_mixer,
5345 alc260_capture_alt_mixer },
5346 .init_verbs = { alc260_init_verbs,
5347 alc260_hp_dc7600_verbs },
5348 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5349 .dac_nids = alc260_dac_nids,
5350 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5351 .adc_nids = alc260_hp_adc_nids,
5352 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5353 .channel_mode = alc260_modes,
5354 .input_mux = &alc260_capture_source,
5355 .unsol_event = alc260_hp_3012_unsol_event,
5356 .init_hook = alc260_hp_3012_automute,
5358 [ALC260_HP_3013] = {
5359 .mixers = { alc260_hp_3013_mixer,
5361 alc260_capture_alt_mixer },
5362 .init_verbs = { alc260_hp_3013_init_verbs,
5363 alc260_hp_3013_unsol_verbs },
5364 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5365 .dac_nids = alc260_dac_nids,
5366 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5367 .adc_nids = alc260_hp_adc_nids,
5368 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5369 .channel_mode = alc260_modes,
5370 .input_mux = &alc260_capture_source,
5371 .unsol_event = alc260_hp_3013_unsol_event,
5372 .init_hook = alc260_hp_3013_automute,
5374 [ALC260_FUJITSU_S702X] = {
5375 .mixers = { alc260_fujitsu_mixer,
5376 alc260_capture_mixer },
5377 .init_verbs = { alc260_fujitsu_init_verbs },
5378 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5379 .dac_nids = alc260_dac_nids,
5380 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5381 .adc_nids = alc260_dual_adc_nids,
5382 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5383 .channel_mode = alc260_modes,
5384 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5385 .input_mux = alc260_fujitsu_capture_sources,
5388 .mixers = { alc260_acer_mixer,
5389 alc260_capture_mixer },
5390 .init_verbs = { alc260_acer_init_verbs },
5391 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5392 .dac_nids = alc260_dac_nids,
5393 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5394 .adc_nids = alc260_dual_adc_nids,
5395 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5396 .channel_mode = alc260_modes,
5397 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5398 .input_mux = alc260_acer_capture_sources,
5401 .mixers = { alc260_will_mixer,
5402 alc260_capture_mixer },
5403 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5404 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5405 .dac_nids = alc260_dac_nids,
5406 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5407 .adc_nids = alc260_adc_nids,
5408 .dig_out_nid = ALC260_DIGOUT_NID,
5409 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5410 .channel_mode = alc260_modes,
5411 .input_mux = &alc260_capture_source,
5413 [ALC260_REPLACER_672V] = {
5414 .mixers = { alc260_replacer_672v_mixer,
5415 alc260_capture_mixer },
5416 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5417 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5418 .dac_nids = alc260_dac_nids,
5419 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5420 .adc_nids = alc260_adc_nids,
5421 .dig_out_nid = ALC260_DIGOUT_NID,
5422 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5423 .channel_mode = alc260_modes,
5424 .input_mux = &alc260_capture_source,
5425 .unsol_event = alc260_replacer_672v_unsol_event,
5426 .init_hook = alc260_replacer_672v_automute,
5428 #ifdef CONFIG_SND_DEBUG
5430 .mixers = { alc260_test_mixer,
5431 alc260_capture_mixer },
5432 .init_verbs = { alc260_test_init_verbs },
5433 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5434 .dac_nids = alc260_test_dac_nids,
5435 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5436 .adc_nids = alc260_test_adc_nids,
5437 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5438 .channel_mode = alc260_modes,
5439 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5440 .input_mux = alc260_test_capture_sources,
5445 static int patch_alc260(struct hda_codec *codec)
5447 struct alc_spec *spec;
5448 int err, board_config;
5450 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5456 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5459 if (board_config < 0) {
5460 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5461 "trying auto-probe from BIOS...\n");
5462 board_config = ALC260_AUTO;
5465 if (board_config == ALC260_AUTO) {
5466 /* automatic parse from the BIOS config */
5467 err = alc260_parse_auto_config(codec);
5473 "hda_codec: Cannot set up configuration "
5474 "from BIOS. Using base mode...\n");
5475 board_config = ALC260_BASIC;
5479 if (board_config != ALC260_AUTO)
5480 setup_preset(spec, &alc260_presets[board_config]);
5482 spec->stream_name_analog = "ALC260 Analog";
5483 spec->stream_analog_playback = &alc260_pcm_analog_playback;
5484 spec->stream_analog_capture = &alc260_pcm_analog_capture;
5486 spec->stream_name_digital = "ALC260 Digital";
5487 spec->stream_digital_playback = &alc260_pcm_digital_playback;
5488 spec->stream_digital_capture = &alc260_pcm_digital_capture;
5490 spec->vmaster_nid = 0x08;
5492 codec->patch_ops = alc_patch_ops;
5493 if (board_config == ALC260_AUTO)
5494 spec->init_hook = alc260_auto_init;
5495 #ifdef CONFIG_SND_HDA_POWER_SAVE
5496 if (!spec->loopback.amplist)
5497 spec->loopback.amplist = alc260_loopbacks;
5507 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5508 * configuration. Each pin widget can choose any input DACs and a mixer.
5509 * Each ADC is connected from a mixer of all inputs. This makes possible
5510 * 6-channel independent captures.
5512 * In addition, an independent DAC for the multi-playback (not used in this
5515 #define ALC882_DIGOUT_NID 0x06
5516 #define ALC882_DIGIN_NID 0x0a
5518 static struct hda_channel_mode alc882_ch_modes[1] = {
5522 static hda_nid_t alc882_dac_nids[4] = {
5523 /* front, rear, clfe, rear_surr */
5524 0x02, 0x03, 0x04, 0x05
5527 /* identical with ALC880 */
5528 #define alc882_adc_nids alc880_adc_nids
5529 #define alc882_adc_nids_alt alc880_adc_nids_alt
5531 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5532 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5535 /* FIXME: should be a matrix-type input source selection */
5537 static struct hda_input_mux alc882_capture_source = {
5541 { "Front Mic", 0x1 },
5546 #define alc882_mux_enum_info alc_mux_enum_info
5547 #define alc882_mux_enum_get alc_mux_enum_get
5549 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
5550 struct snd_ctl_elem_value *ucontrol)
5552 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5553 struct alc_spec *spec = codec->spec;
5554 const struct hda_input_mux *imux = spec->input_mux;
5555 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5556 hda_nid_t nid = spec->capsrc_nids ?
5557 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
5558 unsigned int *cur_val = &spec->cur_mux[adc_idx];
5559 unsigned int i, idx;
5561 idx = ucontrol->value.enumerated.item[0];
5562 if (idx >= imux->num_items)
5563 idx = imux->num_items - 1;
5564 if (*cur_val == idx)
5566 for (i = 0; i < imux->num_items; i++) {
5567 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
5568 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
5569 imux->items[i].index,
5579 static struct hda_verb alc882_3ST_ch2_init[] = {
5580 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5581 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5582 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5583 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5590 static struct hda_verb alc882_3ST_ch6_init[] = {
5591 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5592 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5593 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5594 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5595 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5596 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5600 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5601 { 2, alc882_3ST_ch2_init },
5602 { 6, alc882_3ST_ch6_init },
5608 static struct hda_verb alc882_sixstack_ch6_init[] = {
5609 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5610 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5611 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5612 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5619 static struct hda_verb alc882_sixstack_ch8_init[] = {
5620 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5621 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5622 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5623 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5627 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5628 { 6, alc882_sixstack_ch6_init },
5629 { 8, alc882_sixstack_ch8_init },
5633 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
5639 static struct hda_verb alc885_mbp_ch2_init[] = {
5640 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5641 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5642 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5649 static struct hda_verb alc885_mbp_ch6_init[] = {
5650 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5651 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5652 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5653 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5654 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5658 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
5659 { 2, alc885_mbp_ch2_init },
5660 { 6, alc885_mbp_ch6_init },
5664 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5665 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5667 static struct snd_kcontrol_new alc882_base_mixer[] = {
5668 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5669 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5670 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5671 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5672 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5673 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5674 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5675 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5676 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5677 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5678 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5679 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5680 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5681 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5682 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5683 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5684 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5685 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5686 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5687 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5688 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5689 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5690 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5694 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
5695 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5696 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
5697 HDA_CODEC_MUTE ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
5698 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
5699 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5700 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5701 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
5702 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
5703 HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
5704 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
5707 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
5708 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5709 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5710 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5711 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5712 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5713 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5714 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5715 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5716 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5717 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5718 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5722 static struct snd_kcontrol_new alc882_targa_mixer[] = {
5723 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5724 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5725 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5726 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5727 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5728 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5729 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5730 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5731 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5732 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5733 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5734 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5735 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5739 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
5740 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
5742 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
5743 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5744 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5745 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5746 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5747 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5748 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5749 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5750 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5751 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
5752 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
5753 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5754 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5755 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5759 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
5760 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5761 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5762 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5763 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5764 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5765 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5766 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5767 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5768 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5769 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5770 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5771 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5775 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
5777 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5778 .name = "Channel Mode",
5779 .info = alc_ch_mode_info,
5780 .get = alc_ch_mode_get,
5781 .put = alc_ch_mode_put,
5786 static struct hda_verb alc882_init_verbs[] = {
5787 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5788 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5789 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5790 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5792 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5793 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5794 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5796 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5797 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5798 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5800 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5801 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5802 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5804 /* Front Pin: output 0 (0x0c) */
5805 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5806 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5807 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5808 /* Rear Pin: output 1 (0x0d) */
5809 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5810 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5811 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5812 /* CLFE Pin: output 2 (0x0e) */
5813 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5814 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5815 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5816 /* Side Pin: output 3 (0x0f) */
5817 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5818 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5819 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5820 /* Mic (rear) pin: input vref at 80% */
5821 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5822 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5823 /* Front Mic pin: input vref at 80% */
5824 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5825 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5826 /* Line In pin: input */
5827 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5828 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5829 /* Line-2 In: Headphone output (output 0 - 0x0c) */
5830 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5831 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5832 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5833 /* CD pin widget for input */
5834 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5836 /* FIXME: use matrix-type input source selection */
5837 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5838 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5839 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5840 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5841 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5842 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5844 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5845 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5846 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5847 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5849 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5850 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5851 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5852 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5853 /* ADC1: mute amp left and right */
5854 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5855 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5856 /* ADC2: mute amp left and right */
5857 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5858 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5859 /* ADC3: mute amp left and right */
5860 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5861 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5866 static struct hda_verb alc882_eapd_verbs[] = {
5867 /* change to EAPD mode */
5868 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5869 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
5874 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
5875 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5876 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5877 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
5878 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
5879 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
5880 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
5881 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
5885 static struct hda_verb alc882_macpro_init_verbs[] = {
5886 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5887 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5888 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5889 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5890 /* Front Pin: output 0 (0x0c) */
5891 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5892 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5893 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5894 /* Front Mic pin: input vref at 80% */
5895 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5896 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5897 /* Speaker: output */
5898 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5899 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5900 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
5901 /* Headphone output (output 0 - 0x0c) */
5902 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5903 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5904 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5906 /* FIXME: use matrix-type input source selection */
5907 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5908 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5909 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5910 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5911 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5912 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5914 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5915 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5916 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5917 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5919 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5920 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5921 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5922 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5923 /* ADC1: mute amp left and right */
5924 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5925 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5926 /* ADC2: mute amp left and right */
5927 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5928 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5929 /* ADC3: mute amp left and right */
5930 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5931 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5936 /* Macbook Pro rev3 */
5937 static struct hda_verb alc885_mbp3_init_verbs[] = {
5938 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5939 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5940 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5941 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5943 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5944 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5945 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5946 /* Front Pin: output 0 (0x0c) */
5947 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5948 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5949 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5950 /* HP Pin: output 0 (0x0d) */
5951 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
5952 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5953 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5954 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5955 /* Mic (rear) pin: input vref at 80% */
5956 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5957 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5958 /* Front Mic pin: input vref at 80% */
5959 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5960 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5961 /* Line In pin: use output 1 when in LineOut mode */
5962 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5963 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5964 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
5966 /* FIXME: use matrix-type input source selection */
5967 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5968 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5969 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5970 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5971 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5972 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5974 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5975 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5976 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5977 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5979 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5980 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5981 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5982 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5983 /* ADC1: mute amp left and right */
5984 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5985 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5986 /* ADC2: mute amp left and right */
5987 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5988 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5989 /* ADC3: mute amp left and right */
5990 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5991 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5996 /* iMac 24 mixer. */
5997 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
5998 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5999 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6003 /* iMac 24 init verbs. */
6004 static struct hda_verb alc885_imac24_init_verbs[] = {
6005 /* Internal speakers: output 0 (0x0c) */
6006 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6007 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6008 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6009 /* Internal speakers: output 0 (0x0c) */
6010 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6011 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6012 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6013 /* Headphone: output 0 (0x0c) */
6014 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6015 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6016 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6017 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6018 /* Front Mic: input vref at 80% */
6019 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6020 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6024 /* Toggle speaker-output according to the hp-jack state */
6025 static void alc885_imac24_automute(struct hda_codec *codec)
6027 unsigned int present;
6029 present = snd_hda_codec_read(codec, 0x14, 0,
6030 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6031 snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6032 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6033 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6034 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6037 /* Processes unsolicited events. */
6038 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6041 /* Headphone insertion or removal. */
6042 if ((res >> 26) == ALC880_HP_EVENT)
6043 alc885_imac24_automute(codec);
6046 static void alc885_mbp3_automute(struct hda_codec *codec)
6048 unsigned int present;
6050 present = snd_hda_codec_read(codec, 0x15, 0,
6051 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6052 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
6053 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6054 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6055 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6058 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6061 /* Headphone insertion or removal. */
6062 if ((res >> 26) == ALC880_HP_EVENT)
6063 alc885_mbp3_automute(codec);
6067 static struct hda_verb alc882_targa_verbs[] = {
6068 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6069 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6071 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6072 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6074 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6075 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6076 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6078 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6079 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6080 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6081 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6085 /* toggle speaker-output according to the hp-jack state */
6086 static void alc882_targa_automute(struct hda_codec *codec)
6088 unsigned int present;
6090 present = snd_hda_codec_read(codec, 0x14, 0,
6091 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6092 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6093 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6094 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6098 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6100 /* Looks like the unsol event is incompatible with the standard
6101 * definition. 4bit tag is placed at 26 bit!
6103 if (((res >> 26) == ALC880_HP_EVENT)) {
6104 alc882_targa_automute(codec);
6108 static struct hda_verb alc882_asus_a7j_verbs[] = {
6109 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6110 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6112 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6113 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6114 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6116 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6117 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6118 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6120 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6121 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6122 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6126 static struct hda_verb alc882_asus_a7m_verbs[] = {
6127 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6128 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6130 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6131 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6132 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6134 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6135 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6136 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6138 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6139 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6140 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6144 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6146 unsigned int gpiostate, gpiomask, gpiodir;
6148 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6149 AC_VERB_GET_GPIO_DATA, 0);
6152 gpiostate |= (1 << pin);
6154 gpiostate &= ~(1 << pin);
6156 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6157 AC_VERB_GET_GPIO_MASK, 0);
6158 gpiomask |= (1 << pin);
6160 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6161 AC_VERB_GET_GPIO_DIRECTION, 0);
6162 gpiodir |= (1 << pin);
6165 snd_hda_codec_write(codec, codec->afg, 0,
6166 AC_VERB_SET_GPIO_MASK, gpiomask);
6167 snd_hda_codec_write(codec, codec->afg, 0,
6168 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6172 snd_hda_codec_write(codec, codec->afg, 0,
6173 AC_VERB_SET_GPIO_DATA, gpiostate);
6176 /* set up GPIO at initialization */
6177 static void alc885_macpro_init_hook(struct hda_codec *codec)
6179 alc882_gpio_mute(codec, 0, 0);
6180 alc882_gpio_mute(codec, 1, 0);
6183 /* set up GPIO and update auto-muting at initialization */
6184 static void alc885_imac24_init_hook(struct hda_codec *codec)
6186 alc885_macpro_init_hook(codec);
6187 alc885_imac24_automute(codec);
6191 * generic initialization of ADC, input mixers and output mixers
6193 static struct hda_verb alc882_auto_init_verbs[] = {
6195 * Unmute ADC0-2 and set the default input to mic-in
6197 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6198 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6199 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6200 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6201 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6202 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6204 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6206 * Note: PASD motherboards uses the Line In 2 as the input for
6207 * front panel mic (mic 2)
6209 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6210 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6211 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6212 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6213 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6214 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6217 * Set up output mixers (0x0c - 0x0f)
6219 /* set vol=0 to output mixers */
6220 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6221 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6222 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6223 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6224 /* set up input amps for analog loopback */
6225 /* Amp Indices: DAC = 0, mixer = 1 */
6226 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6227 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6228 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6229 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6230 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6231 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6232 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6233 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6234 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6235 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6237 /* FIXME: use matrix-type input source selection */
6238 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6239 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6240 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6241 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6242 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6243 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6245 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6246 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6247 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6248 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6250 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6251 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6252 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6253 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6258 /* capture mixer elements */
6259 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
6260 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6261 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6262 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6263 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6265 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6266 /* The multiple "Capture Source" controls confuse alsamixer
6267 * So call somewhat different..
6269 /* .name = "Capture Source", */
6270 .name = "Input Source",
6272 .info = alc882_mux_enum_info,
6273 .get = alc882_mux_enum_get,
6274 .put = alc882_mux_enum_put,
6279 static struct snd_kcontrol_new alc882_capture_mixer[] = {
6280 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
6281 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
6282 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
6283 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
6284 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
6285 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
6287 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6288 /* The multiple "Capture Source" controls confuse alsamixer
6289 * So call somewhat different..
6291 /* .name = "Capture Source", */
6292 .name = "Input Source",
6294 .info = alc882_mux_enum_info,
6295 .get = alc882_mux_enum_get,
6296 .put = alc882_mux_enum_put,
6301 #ifdef CONFIG_SND_HDA_POWER_SAVE
6302 #define alc882_loopbacks alc880_loopbacks
6305 /* pcm configuration: identiacal with ALC880 */
6306 #define alc882_pcm_analog_playback alc880_pcm_analog_playback
6307 #define alc882_pcm_analog_capture alc880_pcm_analog_capture
6308 #define alc882_pcm_digital_playback alc880_pcm_digital_playback
6309 #define alc882_pcm_digital_capture alc880_pcm_digital_capture
6312 * configuration and preset
6314 static const char *alc882_models[ALC882_MODEL_LAST] = {
6315 [ALC882_3ST_DIG] = "3stack-dig",
6316 [ALC882_6ST_DIG] = "6stack-dig",
6317 [ALC882_ARIMA] = "arima",
6318 [ALC882_W2JC] = "w2jc",
6319 [ALC882_TARGA] = "targa",
6320 [ALC882_ASUS_A7J] = "asus-a7j",
6321 [ALC882_ASUS_A7M] = "asus-a7m",
6322 [ALC885_MACPRO] = "macpro",
6323 [ALC885_MBP3] = "mbp3",
6324 [ALC885_IMAC24] = "imac24",
6325 [ALC882_AUTO] = "auto",
6328 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6329 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6330 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6331 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6332 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6333 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6334 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6335 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6336 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6337 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6338 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */
6339 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6340 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6344 static struct alc_config_preset alc882_presets[] = {
6345 [ALC882_3ST_DIG] = {
6346 .mixers = { alc882_base_mixer },
6347 .init_verbs = { alc882_init_verbs },
6348 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6349 .dac_nids = alc882_dac_nids,
6350 .dig_out_nid = ALC882_DIGOUT_NID,
6351 .dig_in_nid = ALC882_DIGIN_NID,
6352 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6353 .channel_mode = alc882_ch_modes,
6355 .input_mux = &alc882_capture_source,
6357 [ALC882_6ST_DIG] = {
6358 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6359 .init_verbs = { alc882_init_verbs },
6360 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6361 .dac_nids = alc882_dac_nids,
6362 .dig_out_nid = ALC882_DIGOUT_NID,
6363 .dig_in_nid = ALC882_DIGIN_NID,
6364 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6365 .channel_mode = alc882_sixstack_modes,
6366 .input_mux = &alc882_capture_source,
6369 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6370 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6371 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6372 .dac_nids = alc882_dac_nids,
6373 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6374 .channel_mode = alc882_sixstack_modes,
6375 .input_mux = &alc882_capture_source,
6378 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6379 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6380 alc880_gpio1_init_verbs },
6381 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6382 .dac_nids = alc882_dac_nids,
6383 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6384 .channel_mode = alc880_threestack_modes,
6386 .input_mux = &alc882_capture_source,
6387 .dig_out_nid = ALC882_DIGOUT_NID,
6390 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6391 .init_verbs = { alc885_mbp3_init_verbs,
6392 alc880_gpio1_init_verbs },
6393 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6394 .dac_nids = alc882_dac_nids,
6395 .channel_mode = alc885_mbp_6ch_modes,
6396 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6397 .input_mux = &alc882_capture_source,
6398 .dig_out_nid = ALC882_DIGOUT_NID,
6399 .dig_in_nid = ALC882_DIGIN_NID,
6400 .unsol_event = alc885_mbp3_unsol_event,
6401 .init_hook = alc885_mbp3_automute,
6404 .mixers = { alc882_macpro_mixer },
6405 .init_verbs = { alc882_macpro_init_verbs },
6406 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6407 .dac_nids = alc882_dac_nids,
6408 .dig_out_nid = ALC882_DIGOUT_NID,
6409 .dig_in_nid = ALC882_DIGIN_NID,
6410 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6411 .channel_mode = alc882_ch_modes,
6412 .input_mux = &alc882_capture_source,
6413 .init_hook = alc885_macpro_init_hook,
6416 .mixers = { alc885_imac24_mixer },
6417 .init_verbs = { alc885_imac24_init_verbs },
6418 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6419 .dac_nids = alc882_dac_nids,
6420 .dig_out_nid = ALC882_DIGOUT_NID,
6421 .dig_in_nid = ALC882_DIGIN_NID,
6422 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6423 .channel_mode = alc882_ch_modes,
6424 .input_mux = &alc882_capture_source,
6425 .unsol_event = alc885_imac24_unsol_event,
6426 .init_hook = alc885_imac24_init_hook,
6429 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
6430 alc882_capture_mixer },
6431 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6432 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6433 .dac_nids = alc882_dac_nids,
6434 .dig_out_nid = ALC882_DIGOUT_NID,
6435 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6436 .adc_nids = alc882_adc_nids,
6437 .capsrc_nids = alc882_capsrc_nids,
6438 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6439 .channel_mode = alc882_3ST_6ch_modes,
6441 .input_mux = &alc882_capture_source,
6442 .unsol_event = alc882_targa_unsol_event,
6443 .init_hook = alc882_targa_automute,
6445 [ALC882_ASUS_A7J] = {
6446 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
6447 alc882_capture_mixer },
6448 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6449 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6450 .dac_nids = alc882_dac_nids,
6451 .dig_out_nid = ALC882_DIGOUT_NID,
6452 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6453 .adc_nids = alc882_adc_nids,
6454 .capsrc_nids = alc882_capsrc_nids,
6455 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6456 .channel_mode = alc882_3ST_6ch_modes,
6458 .input_mux = &alc882_capture_source,
6460 [ALC882_ASUS_A7M] = {
6461 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6462 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6463 alc880_gpio1_init_verbs,
6464 alc882_asus_a7m_verbs },
6465 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6466 .dac_nids = alc882_dac_nids,
6467 .dig_out_nid = ALC882_DIGOUT_NID,
6468 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6469 .channel_mode = alc880_threestack_modes,
6471 .input_mux = &alc882_capture_source,
6480 PINFIX_ABIT_AW9D_MAX
6483 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6484 { 0x15, 0x01080104 }, /* side */
6485 { 0x16, 0x01011012 }, /* rear */
6486 { 0x17, 0x01016011 }, /* clfe */
6490 static const struct alc_pincfg *alc882_pin_fixes[] = {
6491 [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6494 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6495 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6500 * BIOS auto configuration
6502 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6503 hda_nid_t nid, int pin_type,
6507 struct alc_spec *spec = codec->spec;
6510 alc_set_pin_output(codec, nid, pin_type);
6511 if (spec->multiout.dac_nids[dac_idx] == 0x25)
6514 idx = spec->multiout.dac_nids[dac_idx] - 2;
6515 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6519 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6521 struct alc_spec *spec = codec->spec;
6524 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6525 for (i = 0; i <= HDA_SIDE; i++) {
6526 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6527 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6529 alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6534 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6536 struct alc_spec *spec = codec->spec;
6539 pin = spec->autocfg.hp_pins[0];
6540 if (pin) /* connect to front */
6542 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6543 pin = spec->autocfg.speaker_pins[0];
6545 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6548 #define alc882_is_input_pin(nid) alc880_is_input_pin(nid)
6549 #define ALC882_PIN_CD_NID ALC880_PIN_CD_NID
6551 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6553 struct alc_spec *spec = codec->spec;
6556 for (i = 0; i < AUTO_PIN_LAST; i++) {
6557 hda_nid_t nid = spec->autocfg.input_pins[i];
6562 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
6563 unsigned int pincap;
6564 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
6565 if ((pincap >> AC_PINCAP_VREF_SHIFT) &
6569 snd_hda_codec_write(codec, nid, 0,
6570 AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
6571 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
6572 snd_hda_codec_write(codec, nid, 0,
6573 AC_VERB_SET_AMP_GAIN_MUTE,
6578 static void alc882_auto_init_input_src(struct hda_codec *codec)
6580 struct alc_spec *spec = codec->spec;
6581 const struct hda_input_mux *imux = spec->input_mux;
6584 for (c = 0; c < spec->num_adc_nids; c++) {
6585 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
6586 hda_nid_t nid = spec->capsrc_nids[c];
6587 int conns, mute, idx, item;
6589 conns = snd_hda_get_connections(codec, nid, conn_list,
6590 ARRAY_SIZE(conn_list));
6593 for (idx = 0; idx < conns; idx++) {
6594 /* if the current connection is the selected one,
6595 * unmute it as default - otherwise mute it
6597 mute = AMP_IN_MUTE(idx);
6598 for (item = 0; item < imux->num_items; item++) {
6599 if (imux->items[item].index == idx) {
6600 if (spec->cur_mux[c] == item)
6601 mute = AMP_IN_UNMUTE(idx);
6605 snd_hda_codec_write(codec, nid, 0,
6606 AC_VERB_SET_AMP_GAIN_MUTE, mute);
6611 /* add mic boosts if needed */
6612 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6614 struct alc_spec *spec = codec->spec;
6618 nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6619 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6620 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6622 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6626 nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6627 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6628 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6630 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6637 /* almost identical with ALC880 parser... */
6638 static int alc882_parse_auto_config(struct hda_codec *codec)
6640 struct alc_spec *spec = codec->spec;
6641 int err = alc880_parse_auto_config(codec);
6646 return 0; /* no config found */
6648 err = alc_auto_add_mic_boost(codec);
6652 /* hack - override the init verbs */
6653 spec->init_verbs[0] = alc882_auto_init_verbs;
6655 return 1; /* config found */
6658 /* additional initialization for auto-configuration model */
6659 static void alc882_auto_init(struct hda_codec *codec)
6661 struct alc_spec *spec = codec->spec;
6662 alc882_auto_init_multi_out(codec);
6663 alc882_auto_init_hp_out(codec);
6664 alc882_auto_init_analog_input(codec);
6665 alc882_auto_init_input_src(codec);
6666 if (spec->unsol_event)
6667 alc_inithook(codec);
6670 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
6672 static int patch_alc882(struct hda_codec *codec)
6674 struct alc_spec *spec;
6675 int err, board_config;
6677 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6683 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6687 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6688 /* Pick up systems that don't supply PCI SSID */
6689 switch (codec->subsystem_id) {
6690 case 0x106b0c00: /* Mac Pro */
6691 board_config = ALC885_MACPRO;
6693 case 0x106b1000: /* iMac 24 */
6694 case 0x106b2800: /* AppleTV */
6695 board_config = ALC885_IMAC24;
6697 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
6698 case 0x106b00a4: /* MacbookPro4,1 */
6699 case 0x106b2c00: /* Macbook Pro rev3 */
6700 case 0x106b3600: /* Macbook 3.1 */
6701 board_config = ALC885_MBP3;
6704 /* ALC889A is handled better as ALC888-compatible */
6705 if (codec->revision_id == 0x100101 ||
6706 codec->revision_id == 0x100103) {
6708 return patch_alc883(codec);
6710 printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6711 "trying auto-probe from BIOS...\n");
6712 board_config = ALC882_AUTO;
6716 alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6718 if (board_config == ALC882_AUTO) {
6719 /* automatic parse from the BIOS config */
6720 err = alc882_parse_auto_config(codec);
6726 "hda_codec: Cannot set up configuration "
6727 "from BIOS. Using base mode...\n");
6728 board_config = ALC882_3ST_DIG;
6732 if (board_config != ALC882_AUTO)
6733 setup_preset(spec, &alc882_presets[board_config]);
6735 if (codec->vendor_id == 0x10ec0885) {
6736 spec->stream_name_analog = "ALC885 Analog";
6737 spec->stream_name_digital = "ALC885 Digital";
6739 spec->stream_name_analog = "ALC882 Analog";
6740 spec->stream_name_digital = "ALC882 Digital";
6743 spec->stream_analog_playback = &alc882_pcm_analog_playback;
6744 spec->stream_analog_capture = &alc882_pcm_analog_capture;
6745 /* FIXME: setup DAC5 */
6746 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6747 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6749 spec->stream_digital_playback = &alc882_pcm_digital_playback;
6750 spec->stream_digital_capture = &alc882_pcm_digital_capture;
6752 if (!spec->adc_nids && spec->input_mux) {
6753 /* check whether NID 0x07 is valid */
6754 unsigned int wcap = get_wcaps(codec, 0x07);
6756 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6757 if (wcap != AC_WID_AUD_IN) {
6758 spec->adc_nids = alc882_adc_nids_alt;
6759 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6760 spec->capsrc_nids = alc882_capsrc_nids_alt;
6761 spec->mixers[spec->num_mixers] =
6762 alc882_capture_alt_mixer;
6765 spec->adc_nids = alc882_adc_nids;
6766 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6767 spec->capsrc_nids = alc882_capsrc_nids;
6768 spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6773 spec->vmaster_nid = 0x0c;
6775 codec->patch_ops = alc_patch_ops;
6776 if (board_config == ALC882_AUTO)
6777 spec->init_hook = alc882_auto_init;
6778 #ifdef CONFIG_SND_HDA_POWER_SAVE
6779 if (!spec->loopback.amplist)
6780 spec->loopback.amplist = alc882_loopbacks;
6789 * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6790 * configuration. Each pin widget can choose any input DACs and a mixer.
6791 * Each ADC is connected from a mixer of all inputs. This makes possible
6792 * 6-channel independent captures.
6794 * In addition, an independent DAC for the multi-playback (not used in this
6797 #define ALC883_DIGOUT_NID 0x06
6798 #define ALC883_DIGIN_NID 0x0a
6800 static hda_nid_t alc883_dac_nids[4] = {
6801 /* front, rear, clfe, rear_surr */
6802 0x02, 0x03, 0x04, 0x05
6805 static hda_nid_t alc883_adc_nids[2] = {
6810 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6813 /* FIXME: should be a matrix-type input source selection */
6815 static struct hda_input_mux alc883_capture_source = {
6819 { "Front Mic", 0x1 },
6825 static struct hda_input_mux alc883_3stack_6ch_intel = {
6829 { "Front Mic", 0x0 },
6835 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6843 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6853 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6861 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6865 { "Front Mic", 0x1 },
6870 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6878 #define alc883_mux_enum_info alc_mux_enum_info
6879 #define alc883_mux_enum_get alc_mux_enum_get
6880 /* ALC883 has the ALC882-type input selection */
6881 #define alc883_mux_enum_put alc882_mux_enum_put
6886 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6893 static struct hda_verb alc883_3ST_ch2_init[] = {
6894 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6895 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6896 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6897 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6904 static struct hda_verb alc883_3ST_ch4_init[] = {
6905 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6906 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6907 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6908 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6909 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6916 static struct hda_verb alc883_3ST_ch6_init[] = {
6917 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6918 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6919 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6920 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6921 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6922 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6926 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
6927 { 2, alc883_3ST_ch2_init },
6928 { 4, alc883_3ST_ch4_init },
6929 { 6, alc883_3ST_ch6_init },
6935 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6936 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6937 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6938 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6939 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6946 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6947 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6948 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6949 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6950 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6951 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6958 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6959 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6960 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6961 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6962 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6963 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6964 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6968 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6969 { 2, alc883_3ST_ch2_intel_init },
6970 { 4, alc883_3ST_ch4_intel_init },
6971 { 6, alc883_3ST_ch6_intel_init },
6977 static struct hda_verb alc883_sixstack_ch6_init[] = {
6978 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6979 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6980 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6981 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6988 static struct hda_verb alc883_sixstack_ch8_init[] = {
6989 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6990 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6991 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6992 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6996 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6997 { 6, alc883_sixstack_ch6_init },
6998 { 8, alc883_sixstack_ch8_init },
7001 static struct hda_verb alc883_medion_eapd_verbs[] = {
7002 /* eanable EAPD on medion laptop */
7003 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7004 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7008 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7009 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7012 static struct snd_kcontrol_new alc883_base_mixer[] = {
7013 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7014 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7015 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7016 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7017 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7018 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7019 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7020 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7021 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7022 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7023 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7024 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7025 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7026 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7027 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7028 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7029 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7030 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7031 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7032 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7033 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7034 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7035 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7036 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7037 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7038 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7039 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7041 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7042 /* .name = "Capture Source", */
7043 .name = "Input Source",
7045 .info = alc883_mux_enum_info,
7046 .get = alc883_mux_enum_get,
7047 .put = alc883_mux_enum_put,
7052 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7053 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7054 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7055 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7056 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7057 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7058 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7059 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7060 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7061 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7062 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7063 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7064 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7065 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7066 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7067 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7068 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7069 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7071 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7072 /* .name = "Capture Source", */
7073 .name = "Input Source",
7075 .info = alc883_mux_enum_info,
7076 .get = alc883_mux_enum_get,
7077 .put = alc883_mux_enum_put,
7082 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7083 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7084 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7085 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7086 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7087 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7088 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7089 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7090 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7091 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7092 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7093 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7094 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7095 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7096 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7098 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7099 /* .name = "Capture Source", */
7100 .name = "Input Source",
7102 .info = alc883_mux_enum_info,
7103 .get = alc883_mux_enum_get,
7104 .put = alc883_mux_enum_put,
7109 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7110 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7111 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7112 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7113 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7114 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7115 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7116 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7117 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7118 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7119 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7120 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7121 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7122 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7123 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7125 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7126 /* .name = "Capture Source", */
7127 .name = "Input Source",
7129 .info = alc883_mux_enum_info,
7130 .get = alc883_mux_enum_get,
7131 .put = alc883_mux_enum_put,
7136 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7137 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7138 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7139 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7140 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7141 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7142 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7143 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7144 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7145 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7146 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7147 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7148 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7149 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7150 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7151 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7152 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7153 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7154 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7155 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7157 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7158 /* .name = "Capture Source", */
7159 .name = "Input Source",
7161 .info = alc883_mux_enum_info,
7162 .get = alc883_mux_enum_get,
7163 .put = alc883_mux_enum_put,
7168 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7169 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7170 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7171 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7172 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7173 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7174 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7175 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7176 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7177 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7178 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7179 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7180 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7181 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7182 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7183 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7184 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7185 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7186 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7187 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7188 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7189 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7190 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7191 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7193 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7194 /* .name = "Capture Source", */
7195 .name = "Input Source",
7197 .info = alc883_mux_enum_info,
7198 .get = alc883_mux_enum_get,
7199 .put = alc883_mux_enum_put,
7204 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7205 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7206 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7207 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7208 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7209 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7211 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7212 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7213 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7214 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7215 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7216 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7217 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7218 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7219 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7220 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7221 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7222 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7223 HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7224 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7225 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7226 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7227 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7228 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7229 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7230 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7232 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7233 /* .name = "Capture Source", */
7234 .name = "Input Source",
7236 .info = alc883_mux_enum_info,
7237 .get = alc883_mux_enum_get,
7238 .put = alc883_mux_enum_put,
7243 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7244 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7245 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7246 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7247 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7248 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7249 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7250 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7251 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7252 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7253 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7254 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7255 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7256 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7257 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7258 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7259 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7260 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7261 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7262 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7263 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7264 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7265 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7266 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7269 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7270 /* .name = "Capture Source", */
7271 .name = "Input Source",
7273 .info = alc883_mux_enum_info,
7274 .get = alc883_mux_enum_get,
7275 .put = alc883_mux_enum_put,
7280 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7281 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7282 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7283 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7284 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7285 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7286 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7287 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7288 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7289 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7290 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7291 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7292 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7293 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7294 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7295 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7296 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7297 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7298 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7299 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7300 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7302 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7303 /* .name = "Capture Source", */
7304 .name = "Input Source",
7306 .info = alc883_mux_enum_info,
7307 .get = alc883_mux_enum_get,
7308 .put = alc883_mux_enum_put,
7313 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7314 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7315 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7316 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7317 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7318 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7319 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7320 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7321 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7322 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7323 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7324 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7325 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7326 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7327 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7328 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7330 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7331 /* .name = "Capture Source", */
7332 .name = "Input Source",
7334 .info = alc883_mux_enum_info,
7335 .get = alc883_mux_enum_get,
7336 .put = alc883_mux_enum_put,
7341 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7342 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7343 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7344 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7345 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7346 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7347 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7348 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7349 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7350 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7351 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7353 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7354 /* .name = "Capture Source", */
7355 .name = "Input Source",
7357 .info = alc883_mux_enum_info,
7358 .get = alc883_mux_enum_get,
7359 .put = alc883_mux_enum_put,
7364 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7365 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7366 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7367 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7368 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7369 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7370 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7371 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7372 HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7373 HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7374 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7375 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7376 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7377 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7379 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7380 /* .name = "Capture Source", */
7381 .name = "Input Source",
7383 .info = alc883_mux_enum_info,
7384 .get = alc883_mux_enum_get,
7385 .put = alc883_mux_enum_put,
7390 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7391 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7392 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7393 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7394 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7395 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7396 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7397 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7398 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7399 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7400 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7401 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7402 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7403 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7405 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7406 /* .name = "Capture Source", */
7407 .name = "Input Source",
7409 .info = alc883_mux_enum_info,
7410 .get = alc883_mux_enum_get,
7411 .put = alc883_mux_enum_put,
7416 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7417 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7418 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7419 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7420 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7421 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7422 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7423 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7424 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7425 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7426 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7427 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7428 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7430 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7431 /* .name = "Capture Source", */
7432 .name = "Input Source",
7434 .info = alc883_mux_enum_info,
7435 .get = alc883_mux_enum_get,
7436 .put = alc883_mux_enum_put,
7441 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7442 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7443 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7444 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7445 HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7446 HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7447 0x0d, 1, 0x0, HDA_OUTPUT),
7448 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7449 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7450 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7451 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7452 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7453 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7454 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7455 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7456 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7457 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7458 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7459 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7460 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7461 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7462 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7463 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7464 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7465 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7466 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7467 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7468 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7470 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7471 /* .name = "Capture Source", */
7472 .name = "Input Source",
7474 .info = alc883_mux_enum_info,
7475 .get = alc883_mux_enum_get,
7476 .put = alc883_mux_enum_put,
7481 static struct hda_bind_ctls alc883_bind_cap_vol = {
7482 .ops = &snd_hda_bind_vol,
7484 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7485 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7490 static struct hda_bind_ctls alc883_bind_cap_switch = {
7491 .ops = &snd_hda_bind_sw,
7493 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7494 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7499 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7500 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7501 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7502 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7503 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7504 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7505 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7506 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7507 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7508 HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7509 HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7511 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7512 /* .name = "Capture Source", */
7513 .name = "Input Source",
7515 .info = alc883_mux_enum_info,
7516 .get = alc883_mux_enum_get,
7517 .put = alc883_mux_enum_put,
7522 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7524 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7525 .name = "Channel Mode",
7526 .info = alc_ch_mode_info,
7527 .get = alc_ch_mode_get,
7528 .put = alc_ch_mode_put,
7533 static struct hda_verb alc883_init_verbs[] = {
7534 /* ADC1: mute amp left and right */
7535 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7536 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7537 /* ADC2: mute amp left and right */
7538 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7539 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7540 /* Front mixer: unmute input/output amp left and right (volume = 0) */
7541 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7542 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7543 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7545 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7546 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7547 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7549 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7550 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7551 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7553 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7554 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7555 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7557 /* mute analog input loopbacks */
7558 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7559 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7560 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7561 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7562 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7564 /* Front Pin: output 0 (0x0c) */
7565 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7566 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7567 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7568 /* Rear Pin: output 1 (0x0d) */
7569 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7570 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7571 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7572 /* CLFE Pin: output 2 (0x0e) */
7573 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7574 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7575 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7576 /* Side Pin: output 3 (0x0f) */
7577 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7578 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7579 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7580 /* Mic (rear) pin: input vref at 80% */
7581 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7582 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7583 /* Front Mic pin: input vref at 80% */
7584 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7585 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7586 /* Line In pin: input */
7587 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7588 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7589 /* Line-2 In: Headphone output (output 0 - 0x0c) */
7590 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7591 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7592 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7593 /* CD pin widget for input */
7594 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7596 /* FIXME: use matrix-type input source selection */
7597 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7599 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7600 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7601 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7602 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7604 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7605 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7606 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7607 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7611 /* toggle speaker-output according to the hp-jack state */
7612 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7614 unsigned int present;
7616 present = snd_hda_codec_read(codec, 0x15, 0,
7617 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7618 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7619 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7620 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7621 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7624 /* auto-toggle front mic */
7626 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7628 unsigned int present;
7631 present = snd_hda_codec_read(codec, 0x18, 0,
7632 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7633 bits = present ? HDA_AMP_MUTE : 0;
7634 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7638 static void alc883_mitac_automute(struct hda_codec *codec)
7640 alc883_mitac_hp_automute(codec);
7641 /* alc883_mitac_mic_automute(codec); */
7644 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7647 switch (res >> 26) {
7648 case ALC880_HP_EVENT:
7649 alc883_mitac_hp_automute(codec);
7651 case ALC880_MIC_EVENT:
7652 /* alc883_mitac_mic_automute(codec); */
7657 static struct hda_verb alc883_mitac_verbs[] = {
7659 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7660 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7662 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7663 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7665 /* enable unsolicited event */
7666 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7667 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7672 static struct hda_verb alc883_clevo_m720_verbs[] = {
7674 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7675 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7677 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7678 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7680 /* enable unsolicited event */
7681 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7682 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7687 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7689 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7690 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7692 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7693 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7695 /* enable unsolicited event */
7696 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7701 static struct hda_verb alc883_tagra_verbs[] = {
7702 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7703 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7705 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7706 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7708 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7709 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7710 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7712 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7713 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7714 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7715 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7720 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7721 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7722 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7723 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7727 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7728 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7729 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7730 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7731 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7735 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7736 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7737 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7738 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7739 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7740 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7744 static struct hda_verb alc883_haier_w66_verbs[] = {
7745 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7746 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7748 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7750 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7751 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7752 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7753 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7757 static struct hda_verb alc888_lenovo_sky_verbs[] = {
7758 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7759 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7760 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7761 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7762 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7763 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7764 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7765 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7769 static struct hda_verb alc888_3st_hp_verbs[] = {
7770 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */
7771 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */
7772 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */
7776 static struct hda_verb alc888_6st_dell_verbs[] = {
7777 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7781 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7782 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7783 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7784 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7785 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7789 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7790 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7791 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7792 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7793 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7797 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7798 { 2, alc888_3st_hp_2ch_init },
7799 { 6, alc888_3st_hp_6ch_init },
7802 /* toggle front-jack and RCA according to the hp-jack state */
7803 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7805 unsigned int present;
7807 present = snd_hda_codec_read(codec, 0x1b, 0,
7808 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7809 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7810 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7811 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7812 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7815 /* toggle RCA according to the front-jack state */
7816 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7818 unsigned int present;
7820 present = snd_hda_codec_read(codec, 0x14, 0,
7821 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7822 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7823 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7826 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7829 if ((res >> 26) == ALC880_HP_EVENT)
7830 alc888_lenovo_ms7195_front_automute(codec);
7831 if ((res >> 26) == ALC880_FRONT_EVENT)
7832 alc888_lenovo_ms7195_rca_automute(codec);
7835 static struct hda_verb alc883_medion_md2_verbs[] = {
7836 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7837 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7839 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7841 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7845 /* toggle speaker-output according to the hp-jack state */
7846 static void alc883_medion_md2_automute(struct hda_codec *codec)
7848 unsigned int present;
7850 present = snd_hda_codec_read(codec, 0x14, 0,
7851 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7852 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7853 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7856 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7859 if ((res >> 26) == ALC880_HP_EVENT)
7860 alc883_medion_md2_automute(codec);
7863 /* toggle speaker-output according to the hp-jack state */
7864 static void alc883_tagra_automute(struct hda_codec *codec)
7866 unsigned int present;
7869 present = snd_hda_codec_read(codec, 0x14, 0,
7870 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7871 bits = present ? HDA_AMP_MUTE : 0;
7872 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7873 HDA_AMP_MUTE, bits);
7874 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7878 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7880 if ((res >> 26) == ALC880_HP_EVENT)
7881 alc883_tagra_automute(codec);
7884 /* toggle speaker-output according to the hp-jack state */
7885 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
7887 unsigned int present;
7890 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
7891 & AC_PINSENSE_PRESENCE;
7892 bits = present ? HDA_AMP_MUTE : 0;
7893 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7894 HDA_AMP_MUTE, bits);
7897 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
7899 unsigned int present;
7901 present = snd_hda_codec_read(codec, 0x18, 0,
7902 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7903 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
7904 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7907 static void alc883_clevo_m720_automute(struct hda_codec *codec)
7909 alc883_clevo_m720_hp_automute(codec);
7910 alc883_clevo_m720_mic_automute(codec);
7913 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
7916 switch (res >> 26) {
7917 case ALC880_HP_EVENT:
7918 alc883_clevo_m720_hp_automute(codec);
7920 case ALC880_MIC_EVENT:
7921 alc883_clevo_m720_mic_automute(codec);
7926 /* toggle speaker-output according to the hp-jack state */
7927 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
7929 unsigned int present;
7932 present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
7933 & AC_PINSENSE_PRESENCE;
7934 bits = present ? HDA_AMP_MUTE : 0;
7935 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7936 HDA_AMP_MUTE, bits);
7939 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
7942 if ((res >> 26) == ALC880_HP_EVENT)
7943 alc883_2ch_fujitsu_pi2515_automute(codec);
7946 static void alc883_haier_w66_automute(struct hda_codec *codec)
7948 unsigned int present;
7951 present = snd_hda_codec_read(codec, 0x1b, 0,
7952 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7953 bits = present ? 0x80 : 0;
7954 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7958 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
7961 if ((res >> 26) == ALC880_HP_EVENT)
7962 alc883_haier_w66_automute(codec);
7965 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
7967 unsigned int present;
7970 present = snd_hda_codec_read(codec, 0x14, 0,
7971 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7972 bits = present ? HDA_AMP_MUTE : 0;
7973 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7974 HDA_AMP_MUTE, bits);
7977 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
7979 unsigned int present;
7982 present = snd_hda_codec_read(codec, 0x1b, 0,
7983 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7984 bits = present ? HDA_AMP_MUTE : 0;
7985 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7986 HDA_AMP_MUTE, bits);
7987 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7988 HDA_AMP_MUTE, bits);
7991 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
7994 if ((res >> 26) == ALC880_HP_EVENT)
7995 alc883_lenovo_101e_all_automute(codec);
7996 if ((res >> 26) == ALC880_FRONT_EVENT)
7997 alc883_lenovo_101e_ispeaker_automute(codec);
8000 /* toggle speaker-output according to the hp-jack state */
8001 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8003 unsigned int present;
8005 present = snd_hda_codec_read(codec, 0x14, 0,
8006 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8007 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8008 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8009 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8010 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8013 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8016 if ((res >> 26) == ALC880_HP_EVENT)
8017 alc883_acer_aspire_automute(codec);
8020 static struct hda_verb alc883_acer_eapd_verbs[] = {
8021 /* HP Pin: output 0 (0x0c) */
8022 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8023 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8024 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8025 /* Front Pin: output 0 (0x0c) */
8026 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8027 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8028 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8029 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8030 /* eanable EAPD on medion laptop */
8031 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8032 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8033 /* enable unsolicited event */
8034 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8038 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8040 unsigned int present;
8042 present = snd_hda_codec_read(codec, 0x1b, 0,
8043 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8044 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8045 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8046 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8047 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8048 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8049 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8050 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8051 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8054 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8057 switch (res >> 26) {
8058 case ALC880_HP_EVENT:
8059 printk("hp_event\n");
8060 alc888_6st_dell_front_automute(codec);
8065 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8068 unsigned int present;
8070 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8071 present = snd_hda_codec_read(codec, 0x1b, 0,
8072 AC_VERB_GET_PIN_SENSE, 0);
8073 present = (present & 0x80000000) != 0;
8075 /* mute internal speaker */
8076 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8077 HDA_AMP_MUTE, HDA_AMP_MUTE);
8078 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8079 HDA_AMP_MUTE, HDA_AMP_MUTE);
8080 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8081 HDA_AMP_MUTE, HDA_AMP_MUTE);
8082 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8083 HDA_AMP_MUTE, HDA_AMP_MUTE);
8084 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8085 HDA_AMP_MUTE, HDA_AMP_MUTE);
8087 /* unmute internal speaker if necessary */
8088 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8089 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8090 HDA_AMP_MUTE, mute);
8091 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8092 HDA_AMP_MUTE, mute);
8093 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8094 HDA_AMP_MUTE, mute);
8095 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8096 HDA_AMP_MUTE, mute);
8097 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8098 HDA_AMP_MUTE, mute);
8102 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8105 if ((res >> 26) == ALC880_HP_EVENT)
8106 alc888_lenovo_sky_front_automute(codec);
8110 * generic initialization of ADC, input mixers and output mixers
8112 static struct hda_verb alc883_auto_init_verbs[] = {
8114 * Unmute ADC0-2 and set the default input to mic-in
8116 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8117 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8118 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8119 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8121 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8123 * Note: PASD motherboards uses the Line In 2 as the input for
8124 * front panel mic (mic 2)
8126 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8127 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8128 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8129 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8130 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8131 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8134 * Set up output mixers (0x0c - 0x0f)
8136 /* set vol=0 to output mixers */
8137 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8138 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8139 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8140 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8141 /* set up input amps for analog loopback */
8142 /* Amp Indices: DAC = 0, mixer = 1 */
8143 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8144 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8145 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8146 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8147 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8148 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8149 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8150 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8151 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8152 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8154 /* FIXME: use matrix-type input source selection */
8155 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8157 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8158 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8159 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8160 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8161 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8163 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8164 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8165 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8166 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8167 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8172 /* capture mixer elements */
8173 static struct snd_kcontrol_new alc883_capture_mixer[] = {
8174 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
8175 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
8176 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
8177 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
8179 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8180 /* The multiple "Capture Source" controls confuse alsamixer
8181 * So call somewhat different..
8183 /* .name = "Capture Source", */
8184 .name = "Input Source",
8186 .info = alc882_mux_enum_info,
8187 .get = alc882_mux_enum_get,
8188 .put = alc882_mux_enum_put,
8193 static struct hda_verb alc888_asus_m90v_verbs[] = {
8194 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8195 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8196 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8197 /* enable unsolicited event */
8198 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8199 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8203 static void alc883_nb_mic_automute(struct hda_codec *codec)
8205 unsigned int present;
8207 present = snd_hda_codec_read(codec, 0x18, 0,
8208 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8209 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8210 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8211 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8212 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8215 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8217 unsigned int present;
8220 present = snd_hda_codec_read(codec, 0x1b, 0,
8221 AC_VERB_GET_PIN_SENSE, 0)
8222 & AC_PINSENSE_PRESENCE;
8223 bits = present ? 0 : PIN_OUT;
8224 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8226 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8228 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8232 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8235 switch (res >> 26) {
8236 case ALC880_HP_EVENT:
8237 alc883_M90V_speaker_automute(codec);
8239 case ALC880_MIC_EVENT:
8240 alc883_nb_mic_automute(codec);
8245 static void alc883_mode2_inithook(struct hda_codec *codec)
8247 alc883_M90V_speaker_automute(codec);
8248 alc883_nb_mic_automute(codec);
8251 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8252 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8253 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8254 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8255 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8256 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8257 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8258 {0x20, AC_VERB_SET_PROC_COEF, 0x0838},
8259 /* enable unsolicited event */
8260 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8264 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8266 unsigned int present;
8269 present = snd_hda_codec_read(codec, 0x14, 0,
8270 AC_VERB_GET_PIN_SENSE, 0)
8271 & AC_PINSENSE_PRESENCE;
8272 bits = present ? 0 : PIN_OUT;
8273 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8277 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8280 switch (res >> 26) {
8281 case ALC880_HP_EVENT:
8282 alc883_eee1601_speaker_automute(codec);
8287 static void alc883_eee1601_inithook(struct hda_codec *codec)
8289 alc883_eee1601_speaker_automute(codec);
8292 #ifdef CONFIG_SND_HDA_POWER_SAVE
8293 #define alc883_loopbacks alc880_loopbacks
8296 /* pcm configuration: identiacal with ALC880 */
8297 #define alc883_pcm_analog_playback alc880_pcm_analog_playback
8298 #define alc883_pcm_analog_capture alc880_pcm_analog_capture
8299 #define alc883_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
8300 #define alc883_pcm_digital_playback alc880_pcm_digital_playback
8301 #define alc883_pcm_digital_capture alc880_pcm_digital_capture
8304 * configuration and preset
8306 static const char *alc883_models[ALC883_MODEL_LAST] = {
8307 [ALC883_3ST_2ch_DIG] = "3stack-dig",
8308 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig",
8309 [ALC883_3ST_6ch] = "3stack-6ch",
8310 [ALC883_6ST_DIG] = "6stack-dig",
8311 [ALC883_TARGA_DIG] = "targa-dig",
8312 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig",
8313 [ALC883_ACER] = "acer",
8314 [ALC883_ACER_ASPIRE] = "acer-aspire",
8315 [ALC883_MEDION] = "medion",
8316 [ALC883_MEDION_MD2] = "medion-md2",
8317 [ALC883_LAPTOP_EAPD] = "laptop-eapd",
8318 [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8319 [ALC883_LENOVO_NB0763] = "lenovo-nb0763",
8320 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8321 [ALC888_LENOVO_SKY] = "lenovo-sky",
8322 [ALC883_HAIER_W66] = "haier-w66",
8323 [ALC888_3ST_HP] = "3stack-hp",
8324 [ALC888_6ST_DELL] = "6stack-dell",
8325 [ALC883_MITAC] = "mitac",
8326 [ALC883_CLEVO_M720] = "clevo-m720",
8327 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8328 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel",
8329 [ALC883_AUTO] = "auto",
8332 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8333 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8334 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8335 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8336 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8337 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8338 SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
8339 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8340 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8341 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8342 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8343 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8344 SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8345 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8346 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8347 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8348 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8349 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8350 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8351 SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8352 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8353 SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8354 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8355 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8356 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8357 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8358 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8359 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8360 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8361 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8362 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8363 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8364 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8365 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8366 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8367 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8368 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8369 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8370 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8371 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8372 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8373 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8374 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8375 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8376 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8377 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8378 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8379 SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
8380 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8381 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8382 SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8383 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8384 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8385 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8386 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8387 SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8388 SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8389 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8390 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8391 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8392 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8393 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8397 static struct alc_config_preset alc883_presets[] = {
8398 [ALC883_3ST_2ch_DIG] = {
8399 .mixers = { alc883_3ST_2ch_mixer },
8400 .init_verbs = { alc883_init_verbs },
8401 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8402 .dac_nids = alc883_dac_nids,
8403 .dig_out_nid = ALC883_DIGOUT_NID,
8404 .dig_in_nid = ALC883_DIGIN_NID,
8405 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8406 .channel_mode = alc883_3ST_2ch_modes,
8407 .input_mux = &alc883_capture_source,
8409 [ALC883_3ST_6ch_DIG] = {
8410 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8411 .init_verbs = { alc883_init_verbs },
8412 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8413 .dac_nids = alc883_dac_nids,
8414 .dig_out_nid = ALC883_DIGOUT_NID,
8415 .dig_in_nid = ALC883_DIGIN_NID,
8416 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8417 .channel_mode = alc883_3ST_6ch_modes,
8419 .input_mux = &alc883_capture_source,
8421 [ALC883_3ST_6ch] = {
8422 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8423 .init_verbs = { alc883_init_verbs },
8424 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8425 .dac_nids = alc883_dac_nids,
8426 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8427 .channel_mode = alc883_3ST_6ch_modes,
8429 .input_mux = &alc883_capture_source,
8431 [ALC883_3ST_6ch_INTEL] = {
8432 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8433 .init_verbs = { alc883_init_verbs },
8434 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8435 .dac_nids = alc883_dac_nids,
8436 .dig_out_nid = ALC883_DIGOUT_NID,
8437 .dig_in_nid = ALC883_DIGIN_NID,
8438 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8439 .channel_mode = alc883_3ST_6ch_intel_modes,
8441 .input_mux = &alc883_3stack_6ch_intel,
8443 [ALC883_6ST_DIG] = {
8444 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8445 .init_verbs = { alc883_init_verbs },
8446 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8447 .dac_nids = alc883_dac_nids,
8448 .dig_out_nid = ALC883_DIGOUT_NID,
8449 .dig_in_nid = ALC883_DIGIN_NID,
8450 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8451 .channel_mode = alc883_sixstack_modes,
8452 .input_mux = &alc883_capture_source,
8454 [ALC883_TARGA_DIG] = {
8455 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8456 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8457 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8458 .dac_nids = alc883_dac_nids,
8459 .dig_out_nid = ALC883_DIGOUT_NID,
8460 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8461 .channel_mode = alc883_3ST_6ch_modes,
8463 .input_mux = &alc883_capture_source,
8464 .unsol_event = alc883_tagra_unsol_event,
8465 .init_hook = alc883_tagra_automute,
8467 [ALC883_TARGA_2ch_DIG] = {
8468 .mixers = { alc883_tagra_2ch_mixer},
8469 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8470 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8471 .dac_nids = alc883_dac_nids,
8472 .dig_out_nid = ALC883_DIGOUT_NID,
8473 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8474 .channel_mode = alc883_3ST_2ch_modes,
8475 .input_mux = &alc883_capture_source,
8476 .unsol_event = alc883_tagra_unsol_event,
8477 .init_hook = alc883_tagra_automute,
8480 .mixers = { alc883_base_mixer },
8481 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8482 * and the headphone jack. Turn this on and rely on the
8483 * standard mute methods whenever the user wants to turn
8484 * these outputs off.
8486 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8487 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8488 .dac_nids = alc883_dac_nids,
8489 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8490 .channel_mode = alc883_3ST_2ch_modes,
8491 .input_mux = &alc883_capture_source,
8493 [ALC883_ACER_ASPIRE] = {
8494 .mixers = { alc883_acer_aspire_mixer },
8495 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8496 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8497 .dac_nids = alc883_dac_nids,
8498 .dig_out_nid = ALC883_DIGOUT_NID,
8499 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8500 .channel_mode = alc883_3ST_2ch_modes,
8501 .input_mux = &alc883_capture_source,
8502 .unsol_event = alc883_acer_aspire_unsol_event,
8503 .init_hook = alc883_acer_aspire_automute,
8506 .mixers = { alc883_fivestack_mixer,
8507 alc883_chmode_mixer },
8508 .init_verbs = { alc883_init_verbs,
8509 alc883_medion_eapd_verbs },
8510 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8511 .dac_nids = alc883_dac_nids,
8512 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8513 .channel_mode = alc883_sixstack_modes,
8514 .input_mux = &alc883_capture_source,
8516 [ALC883_MEDION_MD2] = {
8517 .mixers = { alc883_medion_md2_mixer},
8518 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8519 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8520 .dac_nids = alc883_dac_nids,
8521 .dig_out_nid = ALC883_DIGOUT_NID,
8522 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8523 .channel_mode = alc883_3ST_2ch_modes,
8524 .input_mux = &alc883_capture_source,
8525 .unsol_event = alc883_medion_md2_unsol_event,
8526 .init_hook = alc883_medion_md2_automute,
8528 [ALC883_LAPTOP_EAPD] = {
8529 .mixers = { alc883_base_mixer },
8530 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8531 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8532 .dac_nids = alc883_dac_nids,
8533 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8534 .channel_mode = alc883_3ST_2ch_modes,
8535 .input_mux = &alc883_capture_source,
8537 [ALC883_CLEVO_M720] = {
8538 .mixers = { alc883_clevo_m720_mixer },
8539 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8540 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8541 .dac_nids = alc883_dac_nids,
8542 .dig_out_nid = ALC883_DIGOUT_NID,
8543 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8544 .channel_mode = alc883_3ST_2ch_modes,
8545 .input_mux = &alc883_capture_source,
8546 .unsol_event = alc883_clevo_m720_unsol_event,
8547 .init_hook = alc883_clevo_m720_automute,
8549 [ALC883_LENOVO_101E_2ch] = {
8550 .mixers = { alc883_lenovo_101e_2ch_mixer},
8551 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8552 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8553 .dac_nids = alc883_dac_nids,
8554 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8555 .channel_mode = alc883_3ST_2ch_modes,
8556 .input_mux = &alc883_lenovo_101e_capture_source,
8557 .unsol_event = alc883_lenovo_101e_unsol_event,
8558 .init_hook = alc883_lenovo_101e_all_automute,
8560 [ALC883_LENOVO_NB0763] = {
8561 .mixers = { alc883_lenovo_nb0763_mixer },
8562 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8563 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8564 .dac_nids = alc883_dac_nids,
8565 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8566 .channel_mode = alc883_3ST_2ch_modes,
8568 .input_mux = &alc883_lenovo_nb0763_capture_source,
8569 .unsol_event = alc883_medion_md2_unsol_event,
8570 .init_hook = alc883_medion_md2_automute,
8572 [ALC888_LENOVO_MS7195_DIG] = {
8573 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8574 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8575 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8576 .dac_nids = alc883_dac_nids,
8577 .dig_out_nid = ALC883_DIGOUT_NID,
8578 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8579 .channel_mode = alc883_3ST_6ch_modes,
8581 .input_mux = &alc883_capture_source,
8582 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8583 .init_hook = alc888_lenovo_ms7195_front_automute,
8585 [ALC883_HAIER_W66] = {
8586 .mixers = { alc883_tagra_2ch_mixer},
8587 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8588 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8589 .dac_nids = alc883_dac_nids,
8590 .dig_out_nid = ALC883_DIGOUT_NID,
8591 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8592 .channel_mode = alc883_3ST_2ch_modes,
8593 .input_mux = &alc883_capture_source,
8594 .unsol_event = alc883_haier_w66_unsol_event,
8595 .init_hook = alc883_haier_w66_automute,
8598 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8599 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8600 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8601 .dac_nids = alc883_dac_nids,
8602 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8603 .channel_mode = alc888_3st_hp_modes,
8605 .input_mux = &alc883_capture_source,
8607 [ALC888_6ST_DELL] = {
8608 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8609 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8610 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8611 .dac_nids = alc883_dac_nids,
8612 .dig_out_nid = ALC883_DIGOUT_NID,
8613 .dig_in_nid = ALC883_DIGIN_NID,
8614 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8615 .channel_mode = alc883_sixstack_modes,
8616 .input_mux = &alc883_capture_source,
8617 .unsol_event = alc888_6st_dell_unsol_event,
8618 .init_hook = alc888_6st_dell_front_automute,
8621 .mixers = { alc883_mitac_mixer },
8622 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8623 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8624 .dac_nids = alc883_dac_nids,
8625 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8626 .channel_mode = alc883_3ST_2ch_modes,
8627 .input_mux = &alc883_capture_source,
8628 .unsol_event = alc883_mitac_unsol_event,
8629 .init_hook = alc883_mitac_automute,
8631 [ALC883_FUJITSU_PI2515] = {
8632 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8633 .init_verbs = { alc883_init_verbs,
8634 alc883_2ch_fujitsu_pi2515_verbs},
8635 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8636 .dac_nids = alc883_dac_nids,
8637 .dig_out_nid = ALC883_DIGOUT_NID,
8638 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8639 .channel_mode = alc883_3ST_2ch_modes,
8640 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8641 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8642 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8644 [ALC888_LENOVO_SKY] = {
8645 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
8646 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
8647 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8648 .dac_nids = alc883_dac_nids,
8649 .dig_out_nid = ALC883_DIGOUT_NID,
8650 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
8651 .adc_nids = alc883_adc_nids,
8652 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8653 .channel_mode = alc883_sixstack_modes,
8655 .input_mux = &alc883_lenovo_sky_capture_source,
8656 .unsol_event = alc883_lenovo_sky_unsol_event,
8657 .init_hook = alc888_lenovo_sky_front_automute,
8659 [ALC888_ASUS_M90V] = {
8660 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8661 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
8662 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8663 .dac_nids = alc883_dac_nids,
8664 .dig_out_nid = ALC883_DIGOUT_NID,
8665 .dig_in_nid = ALC883_DIGIN_NID,
8666 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8667 .channel_mode = alc883_3ST_6ch_modes,
8669 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8670 .unsol_event = alc883_mode2_unsol_event,
8671 .init_hook = alc883_mode2_inithook,
8673 [ALC888_ASUS_EEE1601] = {
8674 .mixers = { alc883_asus_eee1601_mixer },
8675 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
8676 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8677 .dac_nids = alc883_dac_nids,
8678 .dig_out_nid = ALC883_DIGOUT_NID,
8679 .dig_in_nid = ALC883_DIGIN_NID,
8680 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8681 .channel_mode = alc883_3ST_2ch_modes,
8683 .input_mux = &alc883_asus_eee1601_capture_source,
8684 .unsol_event = alc883_eee1601_unsol_event,
8685 .init_hook = alc883_eee1601_inithook,
8691 * BIOS auto configuration
8693 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8694 hda_nid_t nid, int pin_type,
8698 struct alc_spec *spec = codec->spec;
8701 alc_set_pin_output(codec, nid, pin_type);
8702 if (spec->multiout.dac_nids[dac_idx] == 0x25)
8705 idx = spec->multiout.dac_nids[dac_idx] - 2;
8706 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8710 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8712 struct alc_spec *spec = codec->spec;
8715 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8716 for (i = 0; i <= HDA_SIDE; i++) {
8717 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8718 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8720 alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8725 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8727 struct alc_spec *spec = codec->spec;
8730 pin = spec->autocfg.hp_pins[0];
8731 if (pin) /* connect to front */
8733 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8734 pin = spec->autocfg.speaker_pins[0];
8736 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8739 #define alc883_is_input_pin(nid) alc880_is_input_pin(nid)
8740 #define ALC883_PIN_CD_NID ALC880_PIN_CD_NID
8742 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8744 struct alc_spec *spec = codec->spec;
8747 for (i = 0; i < AUTO_PIN_LAST; i++) {
8748 hda_nid_t nid = spec->autocfg.input_pins[i];
8749 if (alc883_is_input_pin(nid)) {
8750 snd_hda_codec_write(codec, nid, 0,
8751 AC_VERB_SET_PIN_WIDGET_CONTROL,
8752 (i <= AUTO_PIN_FRONT_MIC ?
8753 PIN_VREF80 : PIN_IN));
8754 if (nid != ALC883_PIN_CD_NID)
8755 snd_hda_codec_write(codec, nid, 0,
8756 AC_VERB_SET_AMP_GAIN_MUTE,
8762 #define alc883_auto_init_input_src alc882_auto_init_input_src
8764 /* almost identical with ALC880 parser... */
8765 static int alc883_parse_auto_config(struct hda_codec *codec)
8767 struct alc_spec *spec = codec->spec;
8768 int err = alc880_parse_auto_config(codec);
8773 return 0; /* no config found */
8775 err = alc_auto_add_mic_boost(codec);
8779 /* hack - override the init verbs */
8780 spec->init_verbs[0] = alc883_auto_init_verbs;
8781 spec->mixers[spec->num_mixers] = alc883_capture_mixer;
8784 return 1; /* config found */
8787 /* additional initialization for auto-configuration model */
8788 static void alc883_auto_init(struct hda_codec *codec)
8790 struct alc_spec *spec = codec->spec;
8791 alc883_auto_init_multi_out(codec);
8792 alc883_auto_init_hp_out(codec);
8793 alc883_auto_init_analog_input(codec);
8794 alc883_auto_init_input_src(codec);
8795 if (spec->unsol_event)
8796 alc_inithook(codec);
8799 static int patch_alc883(struct hda_codec *codec)
8801 struct alc_spec *spec;
8802 int err, board_config;
8804 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8810 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
8812 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
8815 if (board_config < 0) {
8816 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
8817 "trying auto-probe from BIOS...\n");
8818 board_config = ALC883_AUTO;
8821 if (board_config == ALC883_AUTO) {
8822 /* automatic parse from the BIOS config */
8823 err = alc883_parse_auto_config(codec);
8829 "hda_codec: Cannot set up configuration "
8830 "from BIOS. Using base mode...\n");
8831 board_config = ALC883_3ST_2ch_DIG;
8835 if (board_config != ALC883_AUTO)
8836 setup_preset(spec, &alc883_presets[board_config]);
8838 switch (codec->vendor_id) {
8840 if (codec->revision_id == 0x100101) {
8841 spec->stream_name_analog = "ALC1200 Analog";
8842 spec->stream_name_digital = "ALC1200 Digital";
8844 spec->stream_name_analog = "ALC888 Analog";
8845 spec->stream_name_digital = "ALC888 Digital";
8849 spec->stream_name_analog = "ALC889 Analog";
8850 spec->stream_name_digital = "ALC889 Digital";
8853 spec->stream_name_analog = "ALC883 Analog";
8854 spec->stream_name_digital = "ALC883 Digital";
8858 spec->stream_analog_playback = &alc883_pcm_analog_playback;
8859 spec->stream_analog_capture = &alc883_pcm_analog_capture;
8860 spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8862 spec->stream_digital_playback = &alc883_pcm_digital_playback;
8863 spec->stream_digital_capture = &alc883_pcm_digital_capture;
8865 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8866 spec->adc_nids = alc883_adc_nids;
8867 spec->capsrc_nids = alc883_capsrc_nids;
8869 spec->vmaster_nid = 0x0c;
8871 codec->patch_ops = alc_patch_ops;
8872 if (board_config == ALC883_AUTO)
8873 spec->init_hook = alc883_auto_init;
8875 #ifdef CONFIG_SND_HDA_POWER_SAVE
8876 if (!spec->loopback.amplist)
8877 spec->loopback.amplist = alc883_loopbacks;
8887 #define ALC262_DIGOUT_NID ALC880_DIGOUT_NID
8888 #define ALC262_DIGIN_NID ALC880_DIGIN_NID
8890 #define alc262_dac_nids alc260_dac_nids
8891 #define alc262_adc_nids alc882_adc_nids
8892 #define alc262_adc_nids_alt alc882_adc_nids_alt
8893 #define alc262_capsrc_nids alc882_capsrc_nids
8894 #define alc262_capsrc_nids_alt alc882_capsrc_nids_alt
8896 #define alc262_modes alc260_modes
8897 #define alc262_capture_source alc882_capture_source
8899 static hda_nid_t alc262_dmic_adc_nids[1] = {
8904 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
8906 static struct snd_kcontrol_new alc262_base_mixer[] = {
8907 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8908 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8909 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8910 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8911 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8912 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8913 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8914 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8915 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8916 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8917 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8918 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8919 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8920 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8921 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8922 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8923 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8924 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
8928 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
8929 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8930 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8931 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8932 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8933 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8934 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8935 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8936 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8937 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8938 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8939 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8940 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8941 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8942 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8943 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
8944 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8948 /* update HP, line and mono-out pins according to the master switch */
8949 static void alc262_hp_master_update(struct hda_codec *codec)
8951 struct alc_spec *spec = codec->spec;
8952 int val = spec->master_sw;
8955 snd_hda_codec_write_cache(codec, 0x1b, 0,
8956 AC_VERB_SET_PIN_WIDGET_CONTROL,
8958 snd_hda_codec_write_cache(codec, 0x15, 0,
8959 AC_VERB_SET_PIN_WIDGET_CONTROL,
8961 /* mono (speaker) depending on the HP jack sense */
8962 val = val && !spec->jack_present;
8963 snd_hda_codec_write_cache(codec, 0x16, 0,
8964 AC_VERB_SET_PIN_WIDGET_CONTROL,
8968 static void alc262_hp_bpc_automute(struct hda_codec *codec)
8970 struct alc_spec *spec = codec->spec;
8971 unsigned int presence;
8972 presence = snd_hda_codec_read(codec, 0x1b, 0,
8973 AC_VERB_GET_PIN_SENSE, 0);
8974 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8975 alc262_hp_master_update(codec);
8978 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
8980 if ((res >> 26) != ALC880_HP_EVENT)
8982 alc262_hp_bpc_automute(codec);
8985 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
8987 struct alc_spec *spec = codec->spec;
8988 unsigned int presence;
8989 presence = snd_hda_codec_read(codec, 0x15, 0,
8990 AC_VERB_GET_PIN_SENSE, 0);
8991 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8992 alc262_hp_master_update(codec);
8995 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
8998 if ((res >> 26) != ALC880_HP_EVENT)
9000 alc262_hp_wildwest_automute(codec);
9003 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9004 struct snd_ctl_elem_value *ucontrol)
9006 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9007 struct alc_spec *spec = codec->spec;
9008 *ucontrol->value.integer.value = spec->master_sw;
9012 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9013 struct snd_ctl_elem_value *ucontrol)
9015 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9016 struct alc_spec *spec = codec->spec;
9017 int val = !!*ucontrol->value.integer.value;
9019 if (val == spec->master_sw)
9021 spec->master_sw = val;
9022 alc262_hp_master_update(codec);
9026 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9028 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9029 .name = "Master Playback Switch",
9030 .info = snd_ctl_boolean_mono_info,
9031 .get = alc262_hp_master_sw_get,
9032 .put = alc262_hp_master_sw_put,
9034 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9035 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9036 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9037 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9039 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9041 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9042 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9043 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9044 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9045 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9046 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9047 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9048 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9049 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9050 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9051 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9052 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9053 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9054 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9058 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9060 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9061 .name = "Master Playback Switch",
9062 .info = snd_ctl_boolean_mono_info,
9063 .get = alc262_hp_master_sw_get,
9064 .put = alc262_hp_master_sw_put,
9066 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9067 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9068 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9069 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9070 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9072 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9074 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9075 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9076 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9077 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9078 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9079 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9080 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9081 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9082 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9086 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9087 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9088 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9089 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9093 /* mute/unmute internal speaker according to the hp jack and mute state */
9094 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9096 struct alc_spec *spec = codec->spec;
9098 if (force || !spec->sense_updated) {
9099 unsigned int present;
9100 present = snd_hda_codec_read(codec, 0x15, 0,
9101 AC_VERB_GET_PIN_SENSE, 0);
9102 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9103 spec->sense_updated = 1;
9105 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9106 spec->jack_present ? HDA_AMP_MUTE : 0);
9109 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9112 if ((res >> 26) != ALC880_HP_EVENT)
9114 alc262_hp_t5735_automute(codec, 1);
9117 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9119 alc262_hp_t5735_automute(codec, 1);
9122 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9123 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9124 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9125 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9126 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9127 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9128 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9129 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9133 static struct hda_verb alc262_hp_t5735_verbs[] = {
9134 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9135 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9137 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9141 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9142 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9143 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9144 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9145 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9146 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9147 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9151 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9152 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9153 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9154 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9155 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9156 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9157 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9158 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9159 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9160 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9161 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9165 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9172 /* bind hp and internal speaker mute (with plug check) */
9173 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9174 struct snd_ctl_elem_value *ucontrol)
9176 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9177 long *valp = ucontrol->value.integer.value;
9180 /* change hp mute */
9181 change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9183 valp[0] ? 0 : HDA_AMP_MUTE);
9184 change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9186 valp[1] ? 0 : HDA_AMP_MUTE);
9188 /* change speaker according to HP jack state */
9189 struct alc_spec *spec = codec->spec;
9191 if (spec->jack_present)
9192 mute = HDA_AMP_MUTE;
9194 mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9196 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9197 HDA_AMP_MUTE, mute);
9202 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9203 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9205 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9206 .name = "Master Playback Switch",
9207 .info = snd_hda_mixer_amp_switch_info,
9208 .get = snd_hda_mixer_amp_switch_get,
9209 .put = alc262_sony_master_sw_put,
9210 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9212 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9213 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9214 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9215 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9219 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9220 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9221 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9222 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9223 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9224 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9225 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9226 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9230 #define alc262_capture_mixer alc882_capture_mixer
9231 #define alc262_capture_alt_mixer alc882_capture_alt_mixer
9234 * generic initialization of ADC, input mixers and output mixers
9236 static struct hda_verb alc262_init_verbs[] = {
9238 * Unmute ADC0-2 and set the default input to mic-in
9240 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9241 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9242 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9243 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9244 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9245 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9247 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9249 * Note: PASD motherboards uses the Line In 2 as the input for
9250 * front panel mic (mic 2)
9252 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9253 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9254 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9255 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9256 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9257 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9260 * Set up output mixers (0x0c - 0x0e)
9262 /* set vol=0 to output mixers */
9263 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9264 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9265 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9266 /* set up input amps for analog loopback */
9267 /* Amp Indices: DAC = 0, mixer = 1 */
9268 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9269 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9270 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9271 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9272 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9273 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9275 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9276 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9277 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9278 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9279 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9280 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9282 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9283 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9284 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9285 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9286 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9288 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9289 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9291 /* FIXME: use matrix-type input source selection */
9292 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9293 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9294 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9295 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9296 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9297 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9299 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9300 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9301 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9302 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9304 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9305 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9306 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9307 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9312 static struct hda_verb alc262_eapd_verbs[] = {
9313 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9314 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9318 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9319 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9320 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9324 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9325 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9326 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9327 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9329 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9330 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9334 static struct hda_verb alc262_sony_unsol_verbs[] = {
9335 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9336 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9337 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic
9339 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9340 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9344 static struct hda_input_mux alc262_dmic_capture_source = {
9347 { "Int DMic", 0x9 },
9352 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9353 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9354 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9355 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9356 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9357 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9358 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9359 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9361 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9362 /* The multiple "Capture Source" controls confuse alsamixer
9363 * So call somewhat different..
9365 /* .name = "Capture Source", */
9366 .name = "Input Source",
9368 .info = alc_mux_enum_info,
9369 .get = alc_mux_enum_get,
9370 .put = alc_mux_enum_put,
9375 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9376 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9377 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9378 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9379 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9380 {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9381 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9382 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9383 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9387 static void alc262_dmic_automute(struct hda_codec *codec)
9389 unsigned int present;
9391 present = snd_hda_codec_read(codec, 0x18, 0,
9392 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9393 snd_hda_codec_write(codec, 0x22, 0,
9394 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9397 /* toggle speaker-output according to the hp-jack state */
9398 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9400 unsigned int present;
9403 present = snd_hda_codec_read(codec, 0x15, 0,
9404 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9405 bits = present ? 0 : PIN_OUT;
9406 snd_hda_codec_write(codec, 0x14, 0,
9407 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9412 /* unsolicited event for HP jack sensing */
9413 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9416 if ((res >> 26) == ALC880_HP_EVENT)
9417 alc262_toshiba_s06_speaker_automute(codec);
9418 if ((res >> 26) == ALC880_MIC_EVENT)
9419 alc262_dmic_automute(codec);
9423 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9425 alc262_toshiba_s06_speaker_automute(codec);
9426 alc262_dmic_automute(codec);
9429 /* mute/unmute internal speaker according to the hp jack and mute state */
9430 static void alc262_hippo_automute(struct hda_codec *codec)
9432 struct alc_spec *spec = codec->spec;
9434 unsigned int present;
9436 /* need to execute and sync at first */
9437 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9438 present = snd_hda_codec_read(codec, 0x15, 0,
9439 AC_VERB_GET_PIN_SENSE, 0);
9440 spec->jack_present = (present & 0x80000000) != 0;
9441 if (spec->jack_present) {
9442 /* mute internal speaker */
9443 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9444 HDA_AMP_MUTE, HDA_AMP_MUTE);
9446 /* unmute internal speaker if necessary */
9447 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9448 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9449 HDA_AMP_MUTE, mute);
9453 /* unsolicited event for HP jack sensing */
9454 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9457 if ((res >> 26) != ALC880_HP_EVENT)
9459 alc262_hippo_automute(codec);
9462 static void alc262_hippo1_automute(struct hda_codec *codec)
9465 unsigned int present;
9467 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9468 present = snd_hda_codec_read(codec, 0x1b, 0,
9469 AC_VERB_GET_PIN_SENSE, 0);
9470 present = (present & 0x80000000) != 0;
9472 /* mute internal speaker */
9473 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9474 HDA_AMP_MUTE, HDA_AMP_MUTE);
9476 /* unmute internal speaker if necessary */
9477 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9478 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9479 HDA_AMP_MUTE, mute);
9483 /* unsolicited event for HP jack sensing */
9484 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9487 if ((res >> 26) != ALC880_HP_EVENT)
9489 alc262_hippo1_automute(codec);
9495 * 0x16 = internal speaker
9496 * 0x18 = external mic
9499 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9500 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9501 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9503 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9504 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9505 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9507 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9508 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9512 static struct hda_verb alc262_nec_verbs[] = {
9513 /* Unmute Speaker */
9514 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9517 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9518 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9520 /* External mic to headphone */
9521 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9522 /* External mic to speaker */
9523 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9529 * 0x14 = headphone/spdif-out, 0x15 = internal speaker,
9530 * 0x1b = port replicator headphone out
9533 #define ALC_HP_EVENT 0x37
9535 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9536 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9537 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9538 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9539 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9543 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9544 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9545 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9549 static struct hda_input_mux alc262_fujitsu_capture_source = {
9558 static struct hda_input_mux alc262_HP_capture_source = {
9562 { "Front Mic", 0x1 },
9569 static struct hda_input_mux alc262_HP_D7000_capture_source = {
9573 { "Front Mic", 0x2 },
9579 /* mute/unmute internal speaker according to the hp jacks and mute state */
9580 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9582 struct alc_spec *spec = codec->spec;
9585 if (force || !spec->sense_updated) {
9586 unsigned int present;
9587 /* need to execute and sync at first */
9588 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9589 /* check laptop HP jack */
9590 present = snd_hda_codec_read(codec, 0x14, 0,
9591 AC_VERB_GET_PIN_SENSE, 0);
9592 /* need to execute and sync at first */
9593 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9594 /* check docking HP jack */
9595 present |= snd_hda_codec_read(codec, 0x1b, 0,
9596 AC_VERB_GET_PIN_SENSE, 0);
9597 if (present & AC_PINSENSE_PRESENCE)
9598 spec->jack_present = 1;
9600 spec->jack_present = 0;
9601 spec->sense_updated = 1;
9603 /* unmute internal speaker only if both HPs are unplugged and
9604 * master switch is on
9606 if (spec->jack_present)
9607 mute = HDA_AMP_MUTE;
9609 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9610 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9611 HDA_AMP_MUTE, mute);
9614 /* unsolicited event for HP jack sensing */
9615 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9618 if ((res >> 26) != ALC_HP_EVENT)
9620 alc262_fujitsu_automute(codec, 1);
9623 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9625 alc262_fujitsu_automute(codec, 1);
9628 /* bind volumes of both NID 0x0c and 0x0d */
9629 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9630 .ops = &snd_hda_bind_vol,
9632 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9633 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9638 /* mute/unmute internal speaker according to the hp jack and mute state */
9639 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9641 struct alc_spec *spec = codec->spec;
9644 if (force || !spec->sense_updated) {
9645 unsigned int present_int_hp;
9646 /* need to execute and sync at first */
9647 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9648 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9649 AC_VERB_GET_PIN_SENSE, 0);
9650 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9651 spec->sense_updated = 1;
9653 if (spec->jack_present) {
9654 /* mute internal speaker */
9655 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9656 HDA_AMP_MUTE, HDA_AMP_MUTE);
9657 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9658 HDA_AMP_MUTE, HDA_AMP_MUTE);
9660 /* unmute internal speaker if necessary */
9661 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9662 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9663 HDA_AMP_MUTE, mute);
9664 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9665 HDA_AMP_MUTE, mute);
9669 /* unsolicited event for HP jack sensing */
9670 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9673 if ((res >> 26) != ALC_HP_EVENT)
9675 alc262_lenovo_3000_automute(codec, 1);
9678 /* bind hp and internal speaker mute (with plug check) */
9679 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9680 struct snd_ctl_elem_value *ucontrol)
9682 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9683 long *valp = ucontrol->value.integer.value;
9686 change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9688 valp ? 0 : HDA_AMP_MUTE);
9689 change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9691 valp ? 0 : HDA_AMP_MUTE);
9694 alc262_fujitsu_automute(codec, 0);
9698 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9699 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9701 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9702 .name = "Master Playback Switch",
9703 .info = snd_hda_mixer_amp_switch_info,
9704 .get = snd_hda_mixer_amp_switch_get,
9705 .put = alc262_fujitsu_master_sw_put,
9706 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9708 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9709 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9710 HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9711 HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9712 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9713 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9714 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9715 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9716 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9717 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9721 /* bind hp and internal speaker mute (with plug check) */
9722 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9723 struct snd_ctl_elem_value *ucontrol)
9725 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9726 long *valp = ucontrol->value.integer.value;
9729 change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9731 valp ? 0 : HDA_AMP_MUTE);
9734 alc262_lenovo_3000_automute(codec, 0);
9738 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9739 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9741 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9742 .name = "Master Playback Switch",
9743 .info = snd_hda_mixer_amp_switch_info,
9744 .get = snd_hda_mixer_amp_switch_get,
9745 .put = alc262_lenovo_3000_master_sw_put,
9746 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9748 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9749 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9750 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9751 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9752 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9753 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9754 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9755 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9759 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
9760 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9762 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9763 .name = "Master Playback Switch",
9764 .info = snd_hda_mixer_amp_switch_info,
9765 .get = snd_hda_mixer_amp_switch_get,
9766 .put = alc262_sony_master_sw_put,
9767 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9769 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9770 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9771 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9772 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9773 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9774 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9778 /* additional init verbs for Benq laptops */
9779 static struct hda_verb alc262_EAPD_verbs[] = {
9780 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9781 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
9785 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9786 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9787 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9789 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9790 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9794 /* Samsung Q1 Ultra Vista model setup */
9795 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9796 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9797 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9798 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9799 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9800 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9801 HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9805 static struct hda_verb alc262_ultra_verbs[] = {
9807 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9808 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9809 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9811 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9812 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9813 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9814 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9816 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9817 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9818 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9819 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9820 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9822 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9823 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9824 /* ADC, choose mic */
9825 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9826 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9827 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9828 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9829 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9830 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9831 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9832 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9833 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9834 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9838 /* mute/unmute internal speaker according to the hp jack and mute state */
9839 static void alc262_ultra_automute(struct hda_codec *codec)
9841 struct alc_spec *spec = codec->spec;
9845 /* auto-mute only when HP is used as HP */
9846 if (!spec->cur_mux[0]) {
9847 unsigned int present;
9848 /* need to execute and sync at first */
9849 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9850 present = snd_hda_codec_read(codec, 0x15, 0,
9851 AC_VERB_GET_PIN_SENSE, 0);
9852 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9853 if (spec->jack_present)
9854 mute = HDA_AMP_MUTE;
9856 /* mute/unmute internal speaker */
9857 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9858 HDA_AMP_MUTE, mute);
9859 /* mute/unmute HP */
9860 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9861 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9864 /* unsolicited event for HP jack sensing */
9865 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9868 if ((res >> 26) != ALC880_HP_EVENT)
9870 alc262_ultra_automute(codec);
9873 static struct hda_input_mux alc262_ultra_capture_source = {
9877 { "Headphone", 0x7 },
9881 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9882 struct snd_ctl_elem_value *ucontrol)
9884 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9885 struct alc_spec *spec = codec->spec;
9888 ret = alc882_mux_enum_put(kcontrol, ucontrol);
9891 /* reprogram the HP pin as mic or HP according to the input source */
9892 snd_hda_codec_write_cache(codec, 0x15, 0,
9893 AC_VERB_SET_PIN_WIDGET_CONTROL,
9894 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9895 alc262_ultra_automute(codec); /* mute/unmute HP */
9899 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9900 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9901 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9903 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9904 .name = "Capture Source",
9905 .info = alc882_mux_enum_info,
9906 .get = alc882_mux_enum_get,
9907 .put = alc262_ultra_mux_enum_put,
9912 /* add playback controls from the parsed DAC table */
9913 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9914 const struct auto_pin_cfg *cfg)
9919 spec->multiout.num_dacs = 1; /* only use one dac */
9920 spec->multiout.dac_nids = spec->private_dac_nids;
9921 spec->multiout.dac_nids[0] = 2;
9923 nid = cfg->line_out_pins[0];
9925 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9926 "Front Playback Volume",
9927 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
9930 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9931 "Front Playback Switch",
9932 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9937 nid = cfg->speaker_pins[0];
9940 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9941 "Speaker Playback Volume",
9942 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9946 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9947 "Speaker Playback Switch",
9948 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9953 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9954 "Speaker Playback Switch",
9955 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9961 nid = cfg->hp_pins[0];
9963 /* spec->multiout.hp_nid = 2; */
9965 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9966 "Headphone Playback Volume",
9967 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9971 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9972 "Headphone Playback Switch",
9973 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9978 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9979 "Headphone Playback Switch",
9980 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9989 /* identical with ALC880 */
9990 #define alc262_auto_create_analog_input_ctls \
9991 alc880_auto_create_analog_input_ctls
9994 * generic initialization of ADC, input mixers and output mixers
9996 static struct hda_verb alc262_volume_init_verbs[] = {
9998 * Unmute ADC0-2 and set the default input to mic-in
10000 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10001 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10002 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10003 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10004 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10005 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10007 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10009 * Note: PASD motherboards uses the Line In 2 as the input for
10010 * front panel mic (mic 2)
10012 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10013 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10014 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10015 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10016 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10017 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10020 * Set up output mixers (0x0c - 0x0f)
10022 /* set vol=0 to output mixers */
10023 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10024 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10025 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10027 /* set up input amps for analog loopback */
10028 /* Amp Indices: DAC = 0, mixer = 1 */
10029 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10030 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10031 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10032 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10033 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10034 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10036 /* FIXME: use matrix-type input source selection */
10037 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10038 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10039 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10040 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10041 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10042 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10044 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10045 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10046 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10047 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10049 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10050 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10051 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10052 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10057 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10059 * Unmute ADC0-2 and set the default input to mic-in
10061 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10062 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10063 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10064 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10065 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10066 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10068 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10070 * Note: PASD motherboards uses the Line In 2 as the input for
10071 * front panel mic (mic 2)
10073 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10074 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10075 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10076 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10077 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10078 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10079 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10080 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10083 * Set up output mixers (0x0c - 0x0e)
10085 /* set vol=0 to output mixers */
10086 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10087 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10088 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10090 /* set up input amps for analog loopback */
10091 /* Amp Indices: DAC = 0, mixer = 1 */
10092 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10093 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10094 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10095 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10096 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10097 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10099 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10100 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10101 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10103 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10104 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10106 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10107 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10109 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10110 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10111 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10112 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10113 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10115 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10116 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10117 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10118 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10119 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10120 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10123 /* FIXME: use matrix-type input source selection */
10124 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10125 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10126 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10127 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10128 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10129 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10131 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10132 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10133 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10134 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10136 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10137 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10138 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10139 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10141 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10146 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10148 * Unmute ADC0-2 and set the default input to mic-in
10150 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10151 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10152 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10153 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10154 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10155 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10157 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10159 * Note: PASD motherboards uses the Line In 2 as the input for front
10160 * panel mic (mic 2)
10162 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10163 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10164 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10165 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10166 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10167 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10168 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10169 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10170 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10172 * Set up output mixers (0x0c - 0x0e)
10174 /* set vol=0 to output mixers */
10175 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10176 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10177 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10179 /* set up input amps for analog loopback */
10180 /* Amp Indices: DAC = 0, mixer = 1 */
10181 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10182 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10183 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10184 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10185 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10186 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10189 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */
10190 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */
10191 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */
10192 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */
10193 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
10194 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */
10195 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */
10197 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10198 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10200 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10201 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10203 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10204 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10205 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10206 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10207 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10208 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10210 /* FIXME: use matrix-type input source selection */
10211 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10212 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10213 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10214 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10215 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10216 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10217 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10218 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10219 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10221 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10222 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10223 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10224 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10225 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10226 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10227 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10229 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10230 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10231 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10232 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10233 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10234 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10235 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10237 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10242 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10244 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Front Speaker */
10245 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10246 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10248 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* MIC jack */
10249 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
10250 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10251 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10253 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP jack */
10254 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10255 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10260 #ifdef CONFIG_SND_HDA_POWER_SAVE
10261 #define alc262_loopbacks alc880_loopbacks
10264 /* pcm configuration: identiacal with ALC880 */
10265 #define alc262_pcm_analog_playback alc880_pcm_analog_playback
10266 #define alc262_pcm_analog_capture alc880_pcm_analog_capture
10267 #define alc262_pcm_digital_playback alc880_pcm_digital_playback
10268 #define alc262_pcm_digital_capture alc880_pcm_digital_capture
10271 * BIOS auto configuration
10273 static int alc262_parse_auto_config(struct hda_codec *codec)
10275 struct alc_spec *spec = codec->spec;
10277 static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10279 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10283 if (!spec->autocfg.line_outs)
10284 return 0; /* can't find valid BIOS pin config */
10285 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10288 err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10292 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10294 if (spec->autocfg.dig_out_pin)
10295 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10296 if (spec->autocfg.dig_in_pin)
10297 spec->dig_in_nid = ALC262_DIGIN_NID;
10299 if (spec->kctl_alloc)
10300 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10302 spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
10303 spec->num_mux_defs = 1;
10304 spec->input_mux = &spec->private_imux;
10306 err = alc_auto_add_mic_boost(codec);
10313 #define alc262_auto_init_multi_out alc882_auto_init_multi_out
10314 #define alc262_auto_init_hp_out alc882_auto_init_hp_out
10315 #define alc262_auto_init_analog_input alc882_auto_init_analog_input
10316 #define alc262_auto_init_input_src alc882_auto_init_input_src
10319 /* init callback for auto-configuration model -- overriding the default init */
10320 static void alc262_auto_init(struct hda_codec *codec)
10322 struct alc_spec *spec = codec->spec;
10323 alc262_auto_init_multi_out(codec);
10324 alc262_auto_init_hp_out(codec);
10325 alc262_auto_init_analog_input(codec);
10326 alc262_auto_init_input_src(codec);
10327 if (spec->unsol_event)
10328 alc_inithook(codec);
10332 * configuration and preset
10334 static const char *alc262_models[ALC262_MODEL_LAST] = {
10335 [ALC262_BASIC] = "basic",
10336 [ALC262_HIPPO] = "hippo",
10337 [ALC262_HIPPO_1] = "hippo_1",
10338 [ALC262_FUJITSU] = "fujitsu",
10339 [ALC262_HP_BPC] = "hp-bpc",
10340 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10341 [ALC262_HP_TC_T5735] = "hp-tc-t5735",
10342 [ALC262_HP_RP5700] = "hp-rp5700",
10343 [ALC262_BENQ_ED8] = "benq",
10344 [ALC262_BENQ_T31] = "benq-t31",
10345 [ALC262_SONY_ASSAMD] = "sony-assamd",
10346 [ALC262_TOSHIBA_S06] = "toshiba-s06",
10347 [ALC262_TOSHIBA_RX1] = "toshiba-rx1",
10348 [ALC262_ULTRA] = "ultra",
10349 [ALC262_LENOVO_3000] = "lenovo-3000",
10350 [ALC262_NEC] = "nec",
10351 [ALC262_AUTO] = "auto",
10354 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10355 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10356 SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10357 SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
10358 SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
10359 SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
10360 SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
10361 SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
10362 SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
10363 SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
10364 SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
10365 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10366 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10367 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10368 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10369 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10370 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10371 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10372 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10373 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10374 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10375 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10376 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10377 ALC262_HP_TC_T5735),
10378 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10379 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10380 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10381 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10382 SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10383 SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
10384 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10385 ALC262_TOSHIBA_RX1),
10386 SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10387 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10388 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10389 SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
10390 SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
10391 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10392 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10393 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10394 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10398 static struct alc_config_preset alc262_presets[] = {
10400 .mixers = { alc262_base_mixer },
10401 .init_verbs = { alc262_init_verbs },
10402 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10403 .dac_nids = alc262_dac_nids,
10405 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10406 .channel_mode = alc262_modes,
10407 .input_mux = &alc262_capture_source,
10410 .mixers = { alc262_base_mixer },
10411 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10412 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10413 .dac_nids = alc262_dac_nids,
10415 .dig_out_nid = ALC262_DIGOUT_NID,
10416 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10417 .channel_mode = alc262_modes,
10418 .input_mux = &alc262_capture_source,
10419 .unsol_event = alc262_hippo_unsol_event,
10420 .init_hook = alc262_hippo_automute,
10422 [ALC262_HIPPO_1] = {
10423 .mixers = { alc262_hippo1_mixer },
10424 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10425 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10426 .dac_nids = alc262_dac_nids,
10428 .dig_out_nid = ALC262_DIGOUT_NID,
10429 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10430 .channel_mode = alc262_modes,
10431 .input_mux = &alc262_capture_source,
10432 .unsol_event = alc262_hippo1_unsol_event,
10433 .init_hook = alc262_hippo1_automute,
10435 [ALC262_FUJITSU] = {
10436 .mixers = { alc262_fujitsu_mixer },
10437 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10438 alc262_fujitsu_unsol_verbs },
10439 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10440 .dac_nids = alc262_dac_nids,
10442 .dig_out_nid = ALC262_DIGOUT_NID,
10443 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10444 .channel_mode = alc262_modes,
10445 .input_mux = &alc262_fujitsu_capture_source,
10446 .unsol_event = alc262_fujitsu_unsol_event,
10447 .init_hook = alc262_fujitsu_init_hook,
10449 [ALC262_HP_BPC] = {
10450 .mixers = { alc262_HP_BPC_mixer },
10451 .init_verbs = { alc262_HP_BPC_init_verbs },
10452 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10453 .dac_nids = alc262_dac_nids,
10455 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10456 .channel_mode = alc262_modes,
10457 .input_mux = &alc262_HP_capture_source,
10458 .unsol_event = alc262_hp_bpc_unsol_event,
10459 .init_hook = alc262_hp_bpc_automute,
10461 [ALC262_HP_BPC_D7000_WF] = {
10462 .mixers = { alc262_HP_BPC_WildWest_mixer },
10463 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10464 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10465 .dac_nids = alc262_dac_nids,
10467 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10468 .channel_mode = alc262_modes,
10469 .input_mux = &alc262_HP_D7000_capture_source,
10470 .unsol_event = alc262_hp_wildwest_unsol_event,
10471 .init_hook = alc262_hp_wildwest_automute,
10473 [ALC262_HP_BPC_D7000_WL] = {
10474 .mixers = { alc262_HP_BPC_WildWest_mixer,
10475 alc262_HP_BPC_WildWest_option_mixer },
10476 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10477 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10478 .dac_nids = alc262_dac_nids,
10480 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10481 .channel_mode = alc262_modes,
10482 .input_mux = &alc262_HP_D7000_capture_source,
10483 .unsol_event = alc262_hp_wildwest_unsol_event,
10484 .init_hook = alc262_hp_wildwest_automute,
10486 [ALC262_HP_TC_T5735] = {
10487 .mixers = { alc262_hp_t5735_mixer },
10488 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10489 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10490 .dac_nids = alc262_dac_nids,
10492 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10493 .channel_mode = alc262_modes,
10494 .input_mux = &alc262_capture_source,
10495 .unsol_event = alc262_hp_t5735_unsol_event,
10496 .init_hook = alc262_hp_t5735_init_hook,
10498 [ALC262_HP_RP5700] = {
10499 .mixers = { alc262_hp_rp5700_mixer },
10500 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10501 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10502 .dac_nids = alc262_dac_nids,
10503 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10504 .channel_mode = alc262_modes,
10505 .input_mux = &alc262_hp_rp5700_capture_source,
10507 [ALC262_BENQ_ED8] = {
10508 .mixers = { alc262_base_mixer },
10509 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10510 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10511 .dac_nids = alc262_dac_nids,
10513 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10514 .channel_mode = alc262_modes,
10515 .input_mux = &alc262_capture_source,
10517 [ALC262_SONY_ASSAMD] = {
10518 .mixers = { alc262_sony_mixer },
10519 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10520 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10521 .dac_nids = alc262_dac_nids,
10523 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10524 .channel_mode = alc262_modes,
10525 .input_mux = &alc262_capture_source,
10526 .unsol_event = alc262_hippo_unsol_event,
10527 .init_hook = alc262_hippo_automute,
10529 [ALC262_BENQ_T31] = {
10530 .mixers = { alc262_benq_t31_mixer },
10531 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10532 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10533 .dac_nids = alc262_dac_nids,
10535 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10536 .channel_mode = alc262_modes,
10537 .input_mux = &alc262_capture_source,
10538 .unsol_event = alc262_hippo_unsol_event,
10539 .init_hook = alc262_hippo_automute,
10542 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
10543 .init_verbs = { alc262_ultra_verbs },
10544 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10545 .dac_nids = alc262_dac_nids,
10546 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10547 .channel_mode = alc262_modes,
10548 .input_mux = &alc262_ultra_capture_source,
10549 .adc_nids = alc262_adc_nids, /* ADC0 */
10550 .capsrc_nids = alc262_capsrc_nids,
10551 .num_adc_nids = 1, /* single ADC */
10552 .unsol_event = alc262_ultra_unsol_event,
10553 .init_hook = alc262_ultra_automute,
10555 [ALC262_LENOVO_3000] = {
10556 .mixers = { alc262_lenovo_3000_mixer },
10557 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10558 alc262_lenovo_3000_unsol_verbs },
10559 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10560 .dac_nids = alc262_dac_nids,
10562 .dig_out_nid = ALC262_DIGOUT_NID,
10563 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10564 .channel_mode = alc262_modes,
10565 .input_mux = &alc262_fujitsu_capture_source,
10566 .unsol_event = alc262_lenovo_3000_unsol_event,
10569 .mixers = { alc262_nec_mixer },
10570 .init_verbs = { alc262_nec_verbs },
10571 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10572 .dac_nids = alc262_dac_nids,
10574 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10575 .channel_mode = alc262_modes,
10576 .input_mux = &alc262_capture_source,
10578 [ALC262_TOSHIBA_S06] = {
10579 .mixers = { alc262_toshiba_s06_mixer },
10580 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
10581 alc262_eapd_verbs },
10582 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10583 .capsrc_nids = alc262_dmic_capsrc_nids,
10584 .dac_nids = alc262_dac_nids,
10585 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
10586 .dig_out_nid = ALC262_DIGOUT_NID,
10587 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10588 .channel_mode = alc262_modes,
10589 .input_mux = &alc262_dmic_capture_source,
10590 .unsol_event = alc262_toshiba_s06_unsol_event,
10591 .init_hook = alc262_toshiba_s06_init_hook,
10593 [ALC262_TOSHIBA_RX1] = {
10594 .mixers = { alc262_toshiba_rx1_mixer },
10595 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
10596 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10597 .dac_nids = alc262_dac_nids,
10599 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10600 .channel_mode = alc262_modes,
10601 .input_mux = &alc262_capture_source,
10602 .unsol_event = alc262_hippo_unsol_event,
10603 .init_hook = alc262_hippo_automute,
10607 static int patch_alc262(struct hda_codec *codec)
10609 struct alc_spec *spec;
10613 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10617 codec->spec = spec;
10619 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
10624 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10625 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
10626 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10627 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
10631 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10633 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
10637 if (board_config < 0) {
10638 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
10639 "trying auto-probe from BIOS...\n");
10640 board_config = ALC262_AUTO;
10643 if (board_config == ALC262_AUTO) {
10644 /* automatic parse from the BIOS config */
10645 err = alc262_parse_auto_config(codec);
10651 "hda_codec: Cannot set up configuration "
10652 "from BIOS. Using base mode...\n");
10653 board_config = ALC262_BASIC;
10657 if (board_config != ALC262_AUTO)
10658 setup_preset(spec, &alc262_presets[board_config]);
10660 spec->stream_name_analog = "ALC262 Analog";
10661 spec->stream_analog_playback = &alc262_pcm_analog_playback;
10662 spec->stream_analog_capture = &alc262_pcm_analog_capture;
10664 spec->stream_name_digital = "ALC262 Digital";
10665 spec->stream_digital_playback = &alc262_pcm_digital_playback;
10666 spec->stream_digital_capture = &alc262_pcm_digital_capture;
10668 if (!spec->adc_nids && spec->input_mux) {
10669 /* check whether NID 0x07 is valid */
10670 unsigned int wcap = get_wcaps(codec, 0x07);
10673 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10674 if (wcap != AC_WID_AUD_IN) {
10675 spec->adc_nids = alc262_adc_nids_alt;
10676 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
10677 spec->capsrc_nids = alc262_capsrc_nids_alt;
10678 spec->mixers[spec->num_mixers] =
10679 alc262_capture_alt_mixer;
10680 spec->num_mixers++;
10682 spec->adc_nids = alc262_adc_nids;
10683 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
10684 spec->capsrc_nids = alc262_capsrc_nids;
10685 spec->mixers[spec->num_mixers] = alc262_capture_mixer;
10686 spec->num_mixers++;
10690 spec->vmaster_nid = 0x0c;
10692 codec->patch_ops = alc_patch_ops;
10693 if (board_config == ALC262_AUTO)
10694 spec->init_hook = alc262_auto_init;
10695 #ifdef CONFIG_SND_HDA_POWER_SAVE
10696 if (!spec->loopback.amplist)
10697 spec->loopback.amplist = alc262_loopbacks;
10704 * ALC268 channel source setting (2 channel)
10706 #define ALC268_DIGOUT_NID ALC880_DIGOUT_NID
10707 #define alc268_modes alc260_modes
10709 static hda_nid_t alc268_dac_nids[2] = {
10714 static hda_nid_t alc268_adc_nids[2] = {
10719 static hda_nid_t alc268_adc_nids_alt[1] = {
10724 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10726 static struct snd_kcontrol_new alc268_base_mixer[] = {
10727 /* output mixer control */
10728 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10729 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10730 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10731 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10732 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10733 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10734 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10738 /* bind Beep switches of both NID 0x0f and 0x10 */
10739 static struct hda_bind_ctls alc268_bind_beep_sw = {
10740 .ops = &snd_hda_bind_sw,
10742 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10743 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10748 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10749 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10750 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10754 static struct hda_verb alc268_eapd_verbs[] = {
10755 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10756 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10760 /* Toshiba specific */
10761 #define alc268_toshiba_automute alc262_hippo_automute
10763 static struct hda_verb alc268_toshiba_verbs[] = {
10764 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10768 static struct hda_input_mux alc268_acer_lc_capture_source = {
10776 /* Acer specific */
10777 /* bind volumes of both NID 0x02 and 0x03 */
10778 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10779 .ops = &snd_hda_bind_vol,
10781 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10782 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10787 /* mute/unmute internal speaker according to the hp jack and mute state */
10788 static void alc268_acer_automute(struct hda_codec *codec, int force)
10790 struct alc_spec *spec = codec->spec;
10793 if (force || !spec->sense_updated) {
10794 unsigned int present;
10795 present = snd_hda_codec_read(codec, 0x14, 0,
10796 AC_VERB_GET_PIN_SENSE, 0);
10797 spec->jack_present = (present & 0x80000000) != 0;
10798 spec->sense_updated = 1;
10800 if (spec->jack_present)
10801 mute = HDA_AMP_MUTE; /* mute internal speaker */
10802 else /* unmute internal speaker if necessary */
10803 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10804 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10805 HDA_AMP_MUTE, mute);
10809 /* bind hp and internal speaker mute (with plug check) */
10810 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10811 struct snd_ctl_elem_value *ucontrol)
10813 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10814 long *valp = ucontrol->value.integer.value;
10817 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10819 valp[0] ? 0 : HDA_AMP_MUTE);
10820 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10822 valp[1] ? 0 : HDA_AMP_MUTE);
10824 alc268_acer_automute(codec, 0);
10828 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
10829 /* output mixer control */
10830 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10832 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10833 .name = "Master Playback Switch",
10834 .info = snd_hda_mixer_amp_switch_info,
10835 .get = snd_hda_mixer_amp_switch_get,
10836 .put = alc268_acer_master_sw_put,
10837 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10839 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
10843 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10844 /* output mixer control */
10845 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10847 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10848 .name = "Master Playback Switch",
10849 .info = snd_hda_mixer_amp_switch_info,
10850 .get = snd_hda_mixer_amp_switch_get,
10851 .put = alc268_acer_master_sw_put,
10852 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10854 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10855 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10856 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10860 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
10861 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10862 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10863 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10864 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10865 {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
10866 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
10870 static struct hda_verb alc268_acer_verbs[] = {
10871 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10872 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10873 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10874 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10875 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10876 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10877 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10881 /* unsolicited event for HP jack sensing */
10882 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10885 if ((res >> 26) != ALC880_HP_EVENT)
10887 alc268_toshiba_automute(codec);
10890 static void alc268_acer_unsol_event(struct hda_codec *codec,
10893 if ((res >> 26) != ALC880_HP_EVENT)
10895 alc268_acer_automute(codec, 1);
10898 static void alc268_acer_init_hook(struct hda_codec *codec)
10900 alc268_acer_automute(codec, 1);
10903 /* toggle speaker-output according to the hp-jack state */
10904 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
10906 unsigned int present;
10907 unsigned char bits;
10909 present = snd_hda_codec_read(codec, 0x15, 0,
10910 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10911 bits = present ? AMP_IN_MUTE(0) : 0;
10912 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
10913 AMP_IN_MUTE(0), bits);
10914 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
10915 AMP_IN_MUTE(0), bits);
10919 static void alc268_acer_mic_automute(struct hda_codec *codec)
10921 unsigned int present;
10923 present = snd_hda_codec_read(codec, 0x18, 0,
10924 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10925 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
10926 present ? 0x0 : 0x6);
10929 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
10932 if ((res >> 26) == ALC880_HP_EVENT)
10933 alc268_aspire_one_speaker_automute(codec);
10934 if ((res >> 26) == ALC880_MIC_EVENT)
10935 alc268_acer_mic_automute(codec);
10938 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
10940 alc268_aspire_one_speaker_automute(codec);
10941 alc268_acer_mic_automute(codec);
10944 static struct snd_kcontrol_new alc268_dell_mixer[] = {
10945 /* output mixer control */
10946 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10947 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10948 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10949 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10950 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10951 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10955 static struct hda_verb alc268_dell_verbs[] = {
10956 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10957 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10958 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10962 /* mute/unmute internal speaker according to the hp jack and mute state */
10963 static void alc268_dell_automute(struct hda_codec *codec)
10965 unsigned int present;
10968 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
10969 if (present & 0x80000000)
10970 mute = HDA_AMP_MUTE;
10972 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
10973 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10974 HDA_AMP_MUTE, mute);
10977 static void alc268_dell_unsol_event(struct hda_codec *codec,
10980 if ((res >> 26) != ALC880_HP_EVENT)
10982 alc268_dell_automute(codec);
10985 #define alc268_dell_init_hook alc268_dell_automute
10987 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
10988 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10989 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10990 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10991 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10992 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10993 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
10994 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
10995 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10999 static struct hda_verb alc267_quanta_il1_verbs[] = {
11000 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11001 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11005 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11007 unsigned int present;
11009 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11010 & AC_PINSENSE_PRESENCE;
11011 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11012 present ? 0 : PIN_OUT);
11015 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11017 unsigned int present;
11019 present = snd_hda_codec_read(codec, 0x18, 0,
11020 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11021 snd_hda_codec_write(codec, 0x23, 0,
11022 AC_VERB_SET_CONNECT_SEL,
11023 present ? 0x00 : 0x01);
11026 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11028 alc267_quanta_il1_hp_automute(codec);
11029 alc267_quanta_il1_mic_automute(codec);
11032 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11035 switch (res >> 26) {
11036 case ALC880_HP_EVENT:
11037 alc267_quanta_il1_hp_automute(codec);
11039 case ALC880_MIC_EVENT:
11040 alc267_quanta_il1_mic_automute(codec);
11046 * generic initialization of ADC, input mixers and output mixers
11048 static struct hda_verb alc268_base_init_verbs[] = {
11049 /* Unmute DAC0-1 and set vol = 0 */
11050 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11051 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11052 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11053 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11054 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11055 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11058 * Set up output mixers (0x0c - 0x0e)
11060 /* set vol=0 to output mixers */
11061 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11062 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11063 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11064 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11066 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11067 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11069 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11070 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11071 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11072 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11073 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11074 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11075 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11076 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11078 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11079 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11080 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11081 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11082 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11083 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11084 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11086 /* set PCBEEP vol = 0, mute connections */
11087 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11088 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11089 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11091 /* Unmute Selector 23h,24h and set the default input to mic-in */
11093 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11094 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11095 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11096 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11102 * generic initialization of ADC, input mixers and output mixers
11104 static struct hda_verb alc268_volume_init_verbs[] = {
11105 /* set output DAC */
11106 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11107 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11108 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11109 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11111 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11112 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11113 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11114 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11115 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11117 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11118 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11119 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11120 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11121 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11123 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11124 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11125 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11126 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11128 /* set PCBEEP vol = 0, mute connections */
11129 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11130 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11131 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11136 #define alc268_mux_enum_info alc_mux_enum_info
11137 #define alc268_mux_enum_get alc_mux_enum_get
11138 #define alc268_mux_enum_put alc_mux_enum_put
11140 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11141 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11142 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11145 /* The multiple "Capture Source" controls confuse alsamixer
11146 * So call somewhat different..
11148 /* .name = "Capture Source", */
11149 .name = "Input Source",
11151 .info = alc268_mux_enum_info,
11152 .get = alc268_mux_enum_get,
11153 .put = alc268_mux_enum_put,
11158 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11159 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11160 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11161 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11162 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11164 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11165 /* The multiple "Capture Source" controls confuse alsamixer
11166 * So call somewhat different..
11168 /* .name = "Capture Source", */
11169 .name = "Input Source",
11171 .info = alc268_mux_enum_info,
11172 .get = alc268_mux_enum_get,
11173 .put = alc268_mux_enum_put,
11178 static struct hda_input_mux alc268_capture_source = {
11182 { "Front Mic", 0x1 },
11188 static struct hda_input_mux alc268_acer_capture_source = {
11192 { "Internal Mic", 0x6 },
11197 #ifdef CONFIG_SND_DEBUG
11198 static struct snd_kcontrol_new alc268_test_mixer[] = {
11199 /* Volume widgets */
11200 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11201 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11202 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11203 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11204 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11205 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11206 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11207 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11208 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11209 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11210 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11211 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11212 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11213 /* The below appears problematic on some hardwares */
11214 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11215 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11216 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11217 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11218 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11220 /* Modes for retasking pin widgets */
11221 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11222 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11223 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11224 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11226 /* Controls for GPIO pins, assuming they are configured as outputs */
11227 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11228 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11229 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11230 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11232 /* Switches to allow the digital SPDIF output pin to be enabled.
11233 * The ALC268 does not have an SPDIF input.
11235 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11237 /* A switch allowing EAPD to be enabled. Some laptops seem to use
11238 * this output to turn on an external amplifier.
11240 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11241 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11247 /* create input playback/capture controls for the given pin */
11248 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11249 const char *ctlname, int idx)
11254 sprintf(name, "%s Playback Volume", ctlname);
11256 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11257 HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11261 } else if (nid == 0x15) {
11262 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11263 HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11269 sprintf(name, "%s Playback Switch", ctlname);
11270 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11271 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11277 /* add playback controls from the parsed DAC table */
11278 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11279 const struct auto_pin_cfg *cfg)
11284 spec->multiout.num_dacs = 2; /* only use one dac */
11285 spec->multiout.dac_nids = spec->private_dac_nids;
11286 spec->multiout.dac_nids[0] = 2;
11287 spec->multiout.dac_nids[1] = 3;
11289 nid = cfg->line_out_pins[0];
11291 alc268_new_analog_output(spec, nid, "Front", 0);
11293 nid = cfg->speaker_pins[0];
11295 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11296 "Speaker Playback Volume",
11297 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11301 nid = cfg->hp_pins[0];
11303 alc268_new_analog_output(spec, nid, "Headphone", 0);
11305 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11307 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11308 "Mono Playback Switch",
11309 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11316 /* create playback/capture controls for input pins */
11317 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11318 const struct auto_pin_cfg *cfg)
11320 struct hda_input_mux *imux = &spec->private_imux;
11323 for (i = 0; i < AUTO_PIN_LAST; i++) {
11324 switch(cfg->input_pins[i]) {
11326 idx1 = 0; /* Mic 1 */
11329 idx1 = 1; /* Mic 2 */
11332 idx1 = 2; /* Line In */
11339 idx1 = 6; /* digital mics */
11344 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11345 imux->items[imux->num_items].index = idx1;
11351 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11353 struct alc_spec *spec = codec->spec;
11354 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11355 hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11356 hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11357 unsigned int dac_vol1, dac_vol2;
11360 snd_hda_codec_write(codec, speaker_nid, 0,
11361 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11362 snd_hda_codec_write(codec, 0x0f, 0,
11363 AC_VERB_SET_AMP_GAIN_MUTE,
11365 snd_hda_codec_write(codec, 0x10, 0,
11366 AC_VERB_SET_AMP_GAIN_MUTE,
11369 snd_hda_codec_write(codec, 0x0f, 0,
11370 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11371 snd_hda_codec_write(codec, 0x10, 0,
11372 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11375 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */
11376 if (line_nid == 0x14)
11377 dac_vol2 = AMP_OUT_ZERO;
11378 else if (line_nid == 0x15)
11379 dac_vol1 = AMP_OUT_ZERO;
11380 if (hp_nid == 0x14)
11381 dac_vol2 = AMP_OUT_ZERO;
11382 else if (hp_nid == 0x15)
11383 dac_vol1 = AMP_OUT_ZERO;
11384 if (line_nid != 0x16 || hp_nid != 0x16 ||
11385 spec->autocfg.line_out_pins[1] != 0x16 ||
11386 spec->autocfg.line_out_pins[2] != 0x16)
11387 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11389 snd_hda_codec_write(codec, 0x02, 0,
11390 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11391 snd_hda_codec_write(codec, 0x03, 0,
11392 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11395 /* pcm configuration: identiacal with ALC880 */
11396 #define alc268_pcm_analog_playback alc880_pcm_analog_playback
11397 #define alc268_pcm_analog_capture alc880_pcm_analog_capture
11398 #define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
11399 #define alc268_pcm_digital_playback alc880_pcm_digital_playback
11402 * BIOS auto configuration
11404 static int alc268_parse_auto_config(struct hda_codec *codec)
11406 struct alc_spec *spec = codec->spec;
11408 static hda_nid_t alc268_ignore[] = { 0 };
11410 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11414 if (!spec->autocfg.line_outs)
11415 return 0; /* can't find valid BIOS pin config */
11417 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11420 err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11424 spec->multiout.max_channels = 2;
11426 /* digital only support output */
11427 if (spec->autocfg.dig_out_pin)
11428 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11430 if (spec->kctl_alloc)
11431 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11433 if (spec->autocfg.speaker_pins[0] != 0x1d)
11434 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
11436 spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
11437 spec->num_mux_defs = 1;
11438 spec->input_mux = &spec->private_imux;
11440 err = alc_auto_add_mic_boost(codec);
11447 #define alc268_auto_init_multi_out alc882_auto_init_multi_out
11448 #define alc268_auto_init_hp_out alc882_auto_init_hp_out
11449 #define alc268_auto_init_analog_input alc882_auto_init_analog_input
11451 /* init callback for auto-configuration model -- overriding the default init */
11452 static void alc268_auto_init(struct hda_codec *codec)
11454 struct alc_spec *spec = codec->spec;
11455 alc268_auto_init_multi_out(codec);
11456 alc268_auto_init_hp_out(codec);
11457 alc268_auto_init_mono_speaker_out(codec);
11458 alc268_auto_init_analog_input(codec);
11459 if (spec->unsol_event)
11460 alc_inithook(codec);
11464 * configuration and preset
11466 static const char *alc268_models[ALC268_MODEL_LAST] = {
11467 [ALC267_QUANTA_IL1] = "quanta-il1",
11468 [ALC268_3ST] = "3stack",
11469 [ALC268_TOSHIBA] = "toshiba",
11470 [ALC268_ACER] = "acer",
11471 [ALC268_ACER_ASPIRE_ONE] = "acer-aspire",
11472 [ALC268_DELL] = "dell",
11473 [ALC268_ZEPTO] = "zepto",
11474 #ifdef CONFIG_SND_DEBUG
11475 [ALC268_TEST] = "test",
11477 [ALC268_AUTO] = "auto",
11480 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11481 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11482 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11483 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11484 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11485 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11486 SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11487 ALC268_ACER_ASPIRE_ONE),
11488 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11489 SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11490 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11491 SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11492 SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11493 SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11494 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11495 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11496 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11497 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11501 static struct alc_config_preset alc268_presets[] = {
11502 [ALC267_QUANTA_IL1] = {
11503 .mixers = { alc267_quanta_il1_mixer },
11504 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11505 alc267_quanta_il1_verbs },
11506 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11507 .dac_nids = alc268_dac_nids,
11508 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11509 .adc_nids = alc268_adc_nids_alt,
11511 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11512 .channel_mode = alc268_modes,
11513 .input_mux = &alc268_capture_source,
11514 .unsol_event = alc267_quanta_il1_unsol_event,
11515 .init_hook = alc267_quanta_il1_automute,
11518 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11519 alc268_beep_mixer },
11520 .init_verbs = { alc268_base_init_verbs },
11521 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11522 .dac_nids = alc268_dac_nids,
11523 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11524 .adc_nids = alc268_adc_nids_alt,
11525 .capsrc_nids = alc268_capsrc_nids,
11527 .dig_out_nid = ALC268_DIGOUT_NID,
11528 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11529 .channel_mode = alc268_modes,
11530 .input_mux = &alc268_capture_source,
11532 [ALC268_TOSHIBA] = {
11533 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11534 alc268_beep_mixer },
11535 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11536 alc268_toshiba_verbs },
11537 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11538 .dac_nids = alc268_dac_nids,
11539 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11540 .adc_nids = alc268_adc_nids_alt,
11541 .capsrc_nids = alc268_capsrc_nids,
11543 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11544 .channel_mode = alc268_modes,
11545 .input_mux = &alc268_capture_source,
11546 .unsol_event = alc268_toshiba_unsol_event,
11547 .init_hook = alc268_toshiba_automute,
11550 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
11551 alc268_beep_mixer },
11552 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11553 alc268_acer_verbs },
11554 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11555 .dac_nids = alc268_dac_nids,
11556 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11557 .adc_nids = alc268_adc_nids_alt,
11558 .capsrc_nids = alc268_capsrc_nids,
11560 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11561 .channel_mode = alc268_modes,
11562 .input_mux = &alc268_acer_capture_source,
11563 .unsol_event = alc268_acer_unsol_event,
11564 .init_hook = alc268_acer_init_hook,
11566 [ALC268_ACER_ASPIRE_ONE] = {
11567 .mixers = { alc268_acer_aspire_one_mixer,
11568 alc268_capture_alt_mixer },
11569 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11570 alc268_acer_aspire_one_verbs },
11571 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11572 .dac_nids = alc268_dac_nids,
11573 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11574 .adc_nids = alc268_adc_nids_alt,
11575 .capsrc_nids = alc268_capsrc_nids,
11577 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11578 .channel_mode = alc268_modes,
11579 .input_mux = &alc268_acer_lc_capture_source,
11580 .unsol_event = alc268_acer_lc_unsol_event,
11581 .init_hook = alc268_acer_lc_init_hook,
11584 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
11585 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11586 alc268_dell_verbs },
11587 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11588 .dac_nids = alc268_dac_nids,
11590 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11591 .channel_mode = alc268_modes,
11592 .unsol_event = alc268_dell_unsol_event,
11593 .init_hook = alc268_dell_init_hook,
11594 .input_mux = &alc268_capture_source,
11597 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11598 alc268_beep_mixer },
11599 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11600 alc268_toshiba_verbs },
11601 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11602 .dac_nids = alc268_dac_nids,
11603 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11604 .adc_nids = alc268_adc_nids_alt,
11605 .capsrc_nids = alc268_capsrc_nids,
11607 .dig_out_nid = ALC268_DIGOUT_NID,
11608 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11609 .channel_mode = alc268_modes,
11610 .input_mux = &alc268_capture_source,
11611 .unsol_event = alc268_toshiba_unsol_event,
11612 .init_hook = alc268_toshiba_automute
11614 #ifdef CONFIG_SND_DEBUG
11616 .mixers = { alc268_test_mixer, alc268_capture_mixer },
11617 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11618 alc268_volume_init_verbs },
11619 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11620 .dac_nids = alc268_dac_nids,
11621 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11622 .adc_nids = alc268_adc_nids_alt,
11623 .capsrc_nids = alc268_capsrc_nids,
11625 .dig_out_nid = ALC268_DIGOUT_NID,
11626 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11627 .channel_mode = alc268_modes,
11628 .input_mux = &alc268_capture_source,
11633 static int patch_alc268(struct hda_codec *codec)
11635 struct alc_spec *spec;
11639 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
11643 codec->spec = spec;
11645 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
11649 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
11650 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
11651 "trying auto-probe from BIOS...\n");
11652 board_config = ALC268_AUTO;
11655 if (board_config == ALC268_AUTO) {
11656 /* automatic parse from the BIOS config */
11657 err = alc268_parse_auto_config(codec);
11663 "hda_codec: Cannot set up configuration "
11664 "from BIOS. Using base mode...\n");
11665 board_config = ALC268_3ST;
11669 if (board_config != ALC268_AUTO)
11670 setup_preset(spec, &alc268_presets[board_config]);
11672 if (codec->vendor_id == 0x10ec0267) {
11673 spec->stream_name_analog = "ALC267 Analog";
11674 spec->stream_name_digital = "ALC267 Digital";
11676 spec->stream_name_analog = "ALC268 Analog";
11677 spec->stream_name_digital = "ALC268 Digital";
11680 spec->stream_analog_playback = &alc268_pcm_analog_playback;
11681 spec->stream_analog_capture = &alc268_pcm_analog_capture;
11682 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
11684 spec->stream_digital_playback = &alc268_pcm_digital_playback;
11686 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
11687 /* override the amp caps for beep generator */
11688 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
11689 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
11690 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
11691 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11692 (0 << AC_AMPCAP_MUTE_SHIFT));
11694 if (!spec->adc_nids && spec->input_mux) {
11695 /* check whether NID 0x07 is valid */
11696 unsigned int wcap = get_wcaps(codec, 0x07);
11700 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11701 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
11702 spec->adc_nids = alc268_adc_nids_alt;
11703 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
11704 spec->mixers[spec->num_mixers] =
11705 alc268_capture_alt_mixer;
11706 spec->num_mixers++;
11708 spec->adc_nids = alc268_adc_nids;
11709 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
11710 spec->mixers[spec->num_mixers] =
11711 alc268_capture_mixer;
11712 spec->num_mixers++;
11714 spec->capsrc_nids = alc268_capsrc_nids;
11715 /* set default input source */
11716 for (i = 0; i < spec->num_adc_nids; i++)
11717 snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
11718 0, AC_VERB_SET_CONNECT_SEL,
11719 spec->input_mux->items[0].index);
11722 spec->vmaster_nid = 0x02;
11724 codec->patch_ops = alc_patch_ops;
11725 if (board_config == ALC268_AUTO)
11726 spec->init_hook = alc268_auto_init;
11732 * ALC269 channel source setting (2 channel)
11734 #define ALC269_DIGOUT_NID ALC880_DIGOUT_NID
11736 #define alc269_dac_nids alc260_dac_nids
11738 static hda_nid_t alc269_adc_nids[1] = {
11743 static hda_nid_t alc269_capsrc_nids[1] = {
11747 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
11751 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
11759 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
11767 #define alc269_modes alc260_modes
11768 #define alc269_capture_source alc880_lg_lw_capture_source
11770 static struct snd_kcontrol_new alc269_base_mixer[] = {
11771 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11772 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11773 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11774 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11775 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11776 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11777 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11778 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11779 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11780 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11781 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11782 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11783 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11784 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11788 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
11789 /* output mixer control */
11790 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11792 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11793 .name = "Master Playback Switch",
11794 .info = snd_hda_mixer_amp_switch_info,
11795 .get = snd_hda_mixer_amp_switch_get,
11796 .put = alc268_acer_master_sw_put,
11797 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11799 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11800 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11801 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11802 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11803 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11804 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11805 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
11806 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
11810 /* bind volumes of both NID 0x0c and 0x0d */
11811 static struct hda_bind_ctls alc269_epc_bind_vol = {
11812 .ops = &snd_hda_bind_vol,
11814 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11815 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11820 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
11821 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11822 HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
11823 HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11827 /* capture mixer elements */
11828 static struct snd_kcontrol_new alc269_capture_mixer[] = {
11829 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11830 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11832 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11833 /* The multiple "Capture Source" controls confuse alsamixer
11834 * So call somewhat different..
11836 /* .name = "Capture Source", */
11837 .name = "Input Source",
11839 .info = alc_mux_enum_info,
11840 .get = alc_mux_enum_get,
11841 .put = alc_mux_enum_put,
11846 /* capture mixer elements */
11847 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
11848 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11849 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11854 static struct snd_kcontrol_new alc269_beep_mixer[] = {
11855 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11856 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11860 static struct hda_verb alc269_quanta_fl1_verbs[] = {
11861 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11862 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11863 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11864 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11865 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11866 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11870 /* toggle speaker-output according to the hp-jack state */
11871 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
11873 unsigned int present;
11874 unsigned char bits;
11876 present = snd_hda_codec_read(codec, 0x15, 0,
11877 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11878 bits = present ? AMP_IN_MUTE(0) : 0;
11879 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11880 AMP_IN_MUTE(0), bits);
11881 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11882 AMP_IN_MUTE(0), bits);
11884 snd_hda_codec_write(codec, 0x20, 0,
11885 AC_VERB_SET_COEF_INDEX, 0x0c);
11886 snd_hda_codec_write(codec, 0x20, 0,
11887 AC_VERB_SET_PROC_COEF, 0x680);
11889 snd_hda_codec_write(codec, 0x20, 0,
11890 AC_VERB_SET_COEF_INDEX, 0x0c);
11891 snd_hda_codec_write(codec, 0x20, 0,
11892 AC_VERB_SET_PROC_COEF, 0x480);
11895 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
11897 unsigned int present;
11899 present = snd_hda_codec_read(codec, 0x18, 0,
11900 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11901 snd_hda_codec_write(codec, 0x23, 0,
11902 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
11905 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
11908 if ((res >> 26) == ALC880_HP_EVENT)
11909 alc269_quanta_fl1_speaker_automute(codec);
11910 if ((res >> 26) == ALC880_MIC_EVENT)
11911 alc269_quanta_fl1_mic_automute(codec);
11914 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
11916 alc269_quanta_fl1_speaker_automute(codec);
11917 alc269_quanta_fl1_mic_automute(codec);
11920 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
11921 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11922 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
11923 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11924 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
11925 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11926 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11927 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11931 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
11932 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11933 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
11934 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11935 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
11936 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11937 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11941 /* toggle speaker-output according to the hp-jack state */
11942 static void alc269_speaker_automute(struct hda_codec *codec)
11944 unsigned int present;
11945 unsigned char bits;
11947 present = snd_hda_codec_read(codec, 0x15, 0,
11948 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11949 bits = present ? AMP_IN_MUTE(0) : 0;
11950 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11951 AMP_IN_MUTE(0), bits);
11952 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11953 AMP_IN_MUTE(0), bits);
11956 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
11958 unsigned int present;
11960 present = snd_hda_codec_read(codec, 0x18, 0,
11961 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11962 snd_hda_codec_write(codec, 0x23, 0,
11963 AC_VERB_SET_CONNECT_SEL, (present ? 0 : 5));
11966 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
11968 unsigned int present;
11970 present = snd_hda_codec_read(codec, 0x18, 0,
11971 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11972 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11973 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
11974 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11975 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
11978 /* unsolicited event for HP jack sensing */
11979 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
11982 if ((res >> 26) == ALC880_HP_EVENT)
11983 alc269_speaker_automute(codec);
11985 if ((res >> 26) == ALC880_MIC_EVENT)
11986 alc269_eeepc_dmic_automute(codec);
11989 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
11991 alc269_speaker_automute(codec);
11992 alc269_eeepc_dmic_automute(codec);
11995 /* unsolicited event for HP jack sensing */
11996 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
11999 if ((res >> 26) == ALC880_HP_EVENT)
12000 alc269_speaker_automute(codec);
12002 if ((res >> 26) == ALC880_MIC_EVENT)
12003 alc269_eeepc_amic_automute(codec);
12006 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12008 alc269_speaker_automute(codec);
12009 alc269_eeepc_amic_automute(codec);
12013 * generic initialization of ADC, input mixers and output mixers
12015 static struct hda_verb alc269_init_verbs[] = {
12017 * Unmute ADC0 and set the default input to mic-in
12019 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12021 /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12022 * analog-loopback mixer widget
12023 * Note: PASD motherboards uses the Line In 2 as the input for
12024 * front panel mic (mic 2)
12026 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12027 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12028 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12029 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12030 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12031 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12034 * Set up output mixers (0x0c - 0x0e)
12036 /* set vol=0 to output mixers */
12037 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12038 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12040 /* set up input amps for analog loopback */
12041 /* Amp Indices: DAC = 0, mixer = 1 */
12042 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12043 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12044 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12045 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12046 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12047 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12049 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12050 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12051 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12052 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12053 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12054 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12055 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12057 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12058 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12059 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12060 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12061 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12062 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12063 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12065 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12066 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12068 /* FIXME: use matrix-type input source selection */
12069 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12070 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12071 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12072 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12073 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12074 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12077 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12078 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12082 /* add playback controls from the parsed DAC table */
12083 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12084 const struct auto_pin_cfg *cfg)
12089 spec->multiout.num_dacs = 1; /* only use one dac */
12090 spec->multiout.dac_nids = spec->private_dac_nids;
12091 spec->multiout.dac_nids[0] = 2;
12093 nid = cfg->line_out_pins[0];
12095 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12096 "Front Playback Volume",
12097 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12100 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12101 "Front Playback Switch",
12102 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12107 nid = cfg->speaker_pins[0];
12109 if (!cfg->line_out_pins[0]) {
12110 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12111 "Speaker Playback Volume",
12112 HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12118 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12119 "Speaker Playback Switch",
12120 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12125 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12126 "Speaker Playback Switch",
12127 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12133 nid = cfg->hp_pins[0];
12135 /* spec->multiout.hp_nid = 2; */
12136 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12137 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12138 "Headphone Playback Volume",
12139 HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12145 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12146 "Headphone Playback Switch",
12147 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12152 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12153 "Headphone Playback Switch",
12154 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12163 #define alc269_auto_create_analog_input_ctls \
12164 alc880_auto_create_analog_input_ctls
12166 #ifdef CONFIG_SND_HDA_POWER_SAVE
12167 #define alc269_loopbacks alc880_loopbacks
12170 /* pcm configuration: identiacal with ALC880 */
12171 #define alc269_pcm_analog_playback alc880_pcm_analog_playback
12172 #define alc269_pcm_analog_capture alc880_pcm_analog_capture
12173 #define alc269_pcm_digital_playback alc880_pcm_digital_playback
12174 #define alc269_pcm_digital_capture alc880_pcm_digital_capture
12177 * BIOS auto configuration
12179 static int alc269_parse_auto_config(struct hda_codec *codec)
12181 struct alc_spec *spec = codec->spec;
12183 static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12185 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12190 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12193 err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12197 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12199 if (spec->autocfg.dig_out_pin)
12200 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12202 if (spec->kctl_alloc)
12203 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12205 /* create a beep mixer control if the pin 0x1d isn't assigned */
12206 for (i = 0; i < ARRAY_SIZE(spec->autocfg.input_pins); i++)
12207 if (spec->autocfg.input_pins[i] == 0x1d)
12209 if (i >= ARRAY_SIZE(spec->autocfg.input_pins))
12210 spec->mixers[spec->num_mixers++] = alc269_beep_mixer;
12212 spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
12213 spec->num_mux_defs = 1;
12214 spec->input_mux = &spec->private_imux;
12215 /* set default input source */
12216 snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12217 0, AC_VERB_SET_CONNECT_SEL,
12218 spec->input_mux->items[0].index);
12220 err = alc_auto_add_mic_boost(codec);
12224 spec->mixers[spec->num_mixers] = alc269_capture_mixer;
12225 spec->num_mixers++;
12230 #define alc269_auto_init_multi_out alc882_auto_init_multi_out
12231 #define alc269_auto_init_hp_out alc882_auto_init_hp_out
12232 #define alc269_auto_init_analog_input alc882_auto_init_analog_input
12235 /* init callback for auto-configuration model -- overriding the default init */
12236 static void alc269_auto_init(struct hda_codec *codec)
12238 struct alc_spec *spec = codec->spec;
12239 alc269_auto_init_multi_out(codec);
12240 alc269_auto_init_hp_out(codec);
12241 alc269_auto_init_analog_input(codec);
12242 if (spec->unsol_event)
12243 alc_inithook(codec);
12247 * configuration and preset
12249 static const char *alc269_models[ALC269_MODEL_LAST] = {
12250 [ALC269_BASIC] = "basic",
12251 [ALC269_QUANTA_FL1] = "quanta",
12252 [ALC269_ASUS_EEEPC_P703] = "eeepc-p703",
12253 [ALC269_ASUS_EEEPC_P901] = "eeepc-p901"
12256 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12257 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12258 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12259 ALC269_ASUS_EEEPC_P703),
12260 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12261 ALC269_ASUS_EEEPC_P901),
12262 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12263 ALC269_ASUS_EEEPC_P901),
12267 static struct alc_config_preset alc269_presets[] = {
12269 .mixers = { alc269_base_mixer, alc269_capture_mixer },
12270 .init_verbs = { alc269_init_verbs },
12271 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12272 .dac_nids = alc269_dac_nids,
12274 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12275 .channel_mode = alc269_modes,
12276 .input_mux = &alc269_capture_source,
12278 [ALC269_QUANTA_FL1] = {
12279 .mixers = { alc269_quanta_fl1_mixer },
12280 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12281 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12282 .dac_nids = alc269_dac_nids,
12284 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12285 .channel_mode = alc269_modes,
12286 .input_mux = &alc269_capture_source,
12287 .unsol_event = alc269_quanta_fl1_unsol_event,
12288 .init_hook = alc269_quanta_fl1_init_hook,
12290 [ALC269_ASUS_EEEPC_P703] = {
12291 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
12292 .init_verbs = { alc269_init_verbs,
12293 alc269_eeepc_amic_init_verbs },
12294 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12295 .dac_nids = alc269_dac_nids,
12297 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12298 .channel_mode = alc269_modes,
12299 .input_mux = &alc269_eeepc_amic_capture_source,
12300 .unsol_event = alc269_eeepc_amic_unsol_event,
12301 .init_hook = alc269_eeepc_amic_inithook,
12303 [ALC269_ASUS_EEEPC_P901] = {
12304 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
12305 .init_verbs = { alc269_init_verbs,
12306 alc269_eeepc_dmic_init_verbs },
12307 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12308 .dac_nids = alc269_dac_nids,
12310 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12311 .channel_mode = alc269_modes,
12312 .input_mux = &alc269_eeepc_dmic_capture_source,
12313 .unsol_event = alc269_eeepc_dmic_unsol_event,
12314 .init_hook = alc269_eeepc_dmic_inithook,
12318 static int patch_alc269(struct hda_codec *codec)
12320 struct alc_spec *spec;
12324 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12328 codec->spec = spec;
12330 alc_fix_pll_init(codec, 0x20, 0x04, 15);
12332 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12336 if (board_config < 0) {
12337 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
12338 "trying auto-probe from BIOS...\n");
12339 board_config = ALC269_AUTO;
12342 if (board_config == ALC269_AUTO) {
12343 /* automatic parse from the BIOS config */
12344 err = alc269_parse_auto_config(codec);
12350 "hda_codec: Cannot set up configuration "
12351 "from BIOS. Using base mode...\n");
12352 board_config = ALC269_BASIC;
12356 if (board_config != ALC269_AUTO)
12357 setup_preset(spec, &alc269_presets[board_config]);
12359 spec->stream_name_analog = "ALC269 Analog";
12360 spec->stream_analog_playback = &alc269_pcm_analog_playback;
12361 spec->stream_analog_capture = &alc269_pcm_analog_capture;
12363 spec->stream_name_digital = "ALC269 Digital";
12364 spec->stream_digital_playback = &alc269_pcm_digital_playback;
12365 spec->stream_digital_capture = &alc269_pcm_digital_capture;
12367 spec->adc_nids = alc269_adc_nids;
12368 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
12369 spec->capsrc_nids = alc269_capsrc_nids;
12371 codec->patch_ops = alc_patch_ops;
12372 if (board_config == ALC269_AUTO)
12373 spec->init_hook = alc269_auto_init;
12374 #ifdef CONFIG_SND_HDA_POWER_SAVE
12375 if (!spec->loopback.amplist)
12376 spec->loopback.amplist = alc269_loopbacks;
12383 * ALC861 channel source setting (2/6 channel selection for 3-stack)
12387 * set the path ways for 2 channel output
12388 * need to set the codec line out and mic 1 pin widgets to inputs
12390 static struct hda_verb alc861_threestack_ch2_init[] = {
12391 /* set pin widget 1Ah (line in) for input */
12392 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12393 /* set pin widget 18h (mic1/2) for input, for mic also enable
12396 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12398 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12400 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12401 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12407 * need to set the codec line out and mic 1 pin widgets to outputs
12409 static struct hda_verb alc861_threestack_ch6_init[] = {
12410 /* set pin widget 1Ah (line in) for output (Back Surround)*/
12411 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12412 /* set pin widget 18h (mic1) for output (CLFE)*/
12413 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12415 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12416 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12418 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12420 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12421 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12426 static struct hda_channel_mode alc861_threestack_modes[2] = {
12427 { 2, alc861_threestack_ch2_init },
12428 { 6, alc861_threestack_ch6_init },
12430 /* Set mic1 as input and unmute the mixer */
12431 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
12432 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12433 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12436 /* Set mic1 as output and mute mixer */
12437 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
12438 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12439 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12443 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
12444 { 2, alc861_uniwill_m31_ch2_init },
12445 { 4, alc861_uniwill_m31_ch4_init },
12448 /* Set mic1 and line-in as input and unmute the mixer */
12449 static struct hda_verb alc861_asus_ch2_init[] = {
12450 /* set pin widget 1Ah (line in) for input */
12451 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12452 /* set pin widget 18h (mic1/2) for input, for mic also enable
12455 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12457 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12459 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12460 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12464 /* Set mic1 nad line-in as output and mute mixer */
12465 static struct hda_verb alc861_asus_ch6_init[] = {
12466 /* set pin widget 1Ah (line in) for output (Back Surround)*/
12467 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12468 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12469 /* set pin widget 18h (mic1) for output (CLFE)*/
12470 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12471 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12472 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12473 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12475 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12477 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12478 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12483 static struct hda_channel_mode alc861_asus_modes[2] = {
12484 { 2, alc861_asus_ch2_init },
12485 { 6, alc861_asus_ch6_init },
12490 static struct snd_kcontrol_new alc861_base_mixer[] = {
12491 /* output mixer control */
12492 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12493 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12494 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12495 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12496 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12498 /*Input mixer control */
12499 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12500 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12501 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12502 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12503 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12504 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12505 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12506 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12507 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12508 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12510 /* Capture mixer control */
12511 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12512 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12514 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12515 .name = "Capture Source",
12517 .info = alc_mux_enum_info,
12518 .get = alc_mux_enum_get,
12519 .put = alc_mux_enum_put,
12524 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
12525 /* output mixer control */
12526 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12527 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12528 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12529 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12530 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12532 /* Input mixer control */
12533 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12534 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12535 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12536 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12537 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12538 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12539 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12540 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12541 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12542 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12544 /* Capture mixer control */
12545 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12546 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12548 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12549 .name = "Capture Source",
12551 .info = alc_mux_enum_info,
12552 .get = alc_mux_enum_get,
12553 .put = alc_mux_enum_put,
12556 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12557 .name = "Channel Mode",
12558 .info = alc_ch_mode_info,
12559 .get = alc_ch_mode_get,
12560 .put = alc_ch_mode_put,
12561 .private_value = ARRAY_SIZE(alc861_threestack_modes),
12566 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
12567 /* output mixer control */
12568 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12569 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12570 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12572 /*Capture mixer control */
12573 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12574 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12576 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12577 .name = "Capture Source",
12579 .info = alc_mux_enum_info,
12580 .get = alc_mux_enum_get,
12581 .put = alc_mux_enum_put,
12587 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
12588 /* output mixer control */
12589 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12590 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12591 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12592 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12593 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12595 /* Input mixer control */
12596 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12597 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12598 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12599 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12600 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12601 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12602 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12603 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12604 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12605 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12607 /* Capture mixer control */
12608 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12609 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12611 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12612 .name = "Capture Source",
12614 .info = alc_mux_enum_info,
12615 .get = alc_mux_enum_get,
12616 .put = alc_mux_enum_put,
12619 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12620 .name = "Channel Mode",
12621 .info = alc_ch_mode_info,
12622 .get = alc_ch_mode_get,
12623 .put = alc_ch_mode_put,
12624 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
12629 static struct snd_kcontrol_new alc861_asus_mixer[] = {
12630 /* output mixer control */
12631 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12632 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12633 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12634 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12635 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12637 /* Input mixer control */
12638 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12639 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12640 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12641 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12642 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12643 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12644 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12645 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12646 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12647 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
12649 /* Capture mixer control */
12650 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12651 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12653 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12654 .name = "Capture Source",
12656 .info = alc_mux_enum_info,
12657 .get = alc_mux_enum_get,
12658 .put = alc_mux_enum_put,
12661 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12662 .name = "Channel Mode",
12663 .info = alc_ch_mode_info,
12664 .get = alc_ch_mode_get,
12665 .put = alc_ch_mode_put,
12666 .private_value = ARRAY_SIZE(alc861_asus_modes),
12671 /* additional mixer */
12672 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
12673 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12674 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12675 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
12676 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
12681 * generic initialization of ADC, input mixers and output mixers
12683 static struct hda_verb alc861_base_init_verbs[] = {
12685 * Unmute ADC0 and set the default input to mic-in
12687 /* port-A for surround (rear panel) */
12688 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12689 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
12690 /* port-B for mic-in (rear panel) with vref */
12691 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12692 /* port-C for line-in (rear panel) */
12693 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12694 /* port-D for Front */
12695 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12696 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12697 /* port-E for HP out (front panel) */
12698 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12699 /* route front PCM to HP */
12700 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12701 /* port-F for mic-in (front panel) with vref */
12702 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12703 /* port-G for CLFE (rear panel) */
12704 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12705 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12706 /* port-H for side (rear panel) */
12707 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12708 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
12710 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12711 /* route front mic to ADC1*/
12712 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12713 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12715 /* Unmute DAC0~3 & spdif out*/
12716 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12717 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12718 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12719 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12720 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12722 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12723 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12724 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12725 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12726 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12728 /* Unmute Stereo Mixer 15 */
12729 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12730 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12731 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12732 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12734 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12735 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12736 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12737 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12738 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12739 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12740 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12741 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12742 /* hp used DAC 3 (Front) */
12743 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12744 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12749 static struct hda_verb alc861_threestack_init_verbs[] = {
12751 * Unmute ADC0 and set the default input to mic-in
12753 /* port-A for surround (rear panel) */
12754 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12755 /* port-B for mic-in (rear panel) with vref */
12756 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12757 /* port-C for line-in (rear panel) */
12758 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12759 /* port-D for Front */
12760 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12761 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12762 /* port-E for HP out (front panel) */
12763 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12764 /* route front PCM to HP */
12765 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12766 /* port-F for mic-in (front panel) with vref */
12767 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12768 /* port-G for CLFE (rear panel) */
12769 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12770 /* port-H for side (rear panel) */
12771 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12773 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12774 /* route front mic to ADC1*/
12775 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12776 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12777 /* Unmute DAC0~3 & spdif out*/
12778 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12779 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12780 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12781 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12782 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12784 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12785 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12786 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12787 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12788 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12790 /* Unmute Stereo Mixer 15 */
12791 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12792 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12793 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12794 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12796 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12797 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12798 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12799 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12800 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12801 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12802 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12803 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12804 /* hp used DAC 3 (Front) */
12805 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12806 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12810 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
12812 * Unmute ADC0 and set the default input to mic-in
12814 /* port-A for surround (rear panel) */
12815 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12816 /* port-B for mic-in (rear panel) with vref */
12817 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12818 /* port-C for line-in (rear panel) */
12819 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12820 /* port-D for Front */
12821 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12822 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12823 /* port-E for HP out (front panel) */
12824 /* this has to be set to VREF80 */
12825 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12826 /* route front PCM to HP */
12827 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12828 /* port-F for mic-in (front panel) with vref */
12829 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12830 /* port-G for CLFE (rear panel) */
12831 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12832 /* port-H for side (rear panel) */
12833 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12835 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12836 /* route front mic to ADC1*/
12837 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12838 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12839 /* Unmute DAC0~3 & spdif out*/
12840 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12841 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12842 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12843 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12844 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12846 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12847 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12848 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12849 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12850 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12852 /* Unmute Stereo Mixer 15 */
12853 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12854 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12855 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12856 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12858 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12859 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12860 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12861 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12862 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12863 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12864 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12865 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12866 /* hp used DAC 3 (Front) */
12867 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12868 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12872 static struct hda_verb alc861_asus_init_verbs[] = {
12874 * Unmute ADC0 and set the default input to mic-in
12876 /* port-A for surround (rear panel)
12877 * according to codec#0 this is the HP jack
12879 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
12880 /* route front PCM to HP */
12881 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
12882 /* port-B for mic-in (rear panel) with vref */
12883 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12884 /* port-C for line-in (rear panel) */
12885 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12886 /* port-D for Front */
12887 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12888 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12889 /* port-E for HP out (front panel) */
12890 /* this has to be set to VREF80 */
12891 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12892 /* route front PCM to HP */
12893 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12894 /* port-F for mic-in (front panel) with vref */
12895 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12896 /* port-G for CLFE (rear panel) */
12897 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12898 /* port-H for side (rear panel) */
12899 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12901 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12902 /* route front mic to ADC1*/
12903 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12904 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12905 /* Unmute DAC0~3 & spdif out*/
12906 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12907 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12908 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12909 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12910 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12911 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12912 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12913 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12914 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12915 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12917 /* Unmute Stereo Mixer 15 */
12918 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12919 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12920 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12921 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12923 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12924 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12925 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12926 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12927 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12928 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12929 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12930 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12931 /* hp used DAC 3 (Front) */
12932 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12933 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12937 /* additional init verbs for ASUS laptops */
12938 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
12939 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
12940 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
12945 * generic initialization of ADC, input mixers and output mixers
12947 static struct hda_verb alc861_auto_init_verbs[] = {
12949 * Unmute ADC0 and set the default input to mic-in
12951 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
12952 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12954 /* Unmute DAC0~3 & spdif out*/
12955 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12956 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12957 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12958 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12959 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12961 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12962 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12963 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12964 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12965 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12967 /* Unmute Stereo Mixer 15 */
12968 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12969 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12970 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12971 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
12973 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12974 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12975 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12976 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12977 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12978 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12979 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12980 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12982 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12983 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12984 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12985 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12986 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12987 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12988 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12989 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12991 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */
12996 static struct hda_verb alc861_toshiba_init_verbs[] = {
12997 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13002 /* toggle speaker-output according to the hp-jack state */
13003 static void alc861_toshiba_automute(struct hda_codec *codec)
13005 unsigned int present;
13007 present = snd_hda_codec_read(codec, 0x0f, 0,
13008 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13009 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13010 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13011 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13012 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13015 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13018 if ((res >> 26) == ALC880_HP_EVENT)
13019 alc861_toshiba_automute(codec);
13022 /* pcm configuration: identiacal with ALC880 */
13023 #define alc861_pcm_analog_playback alc880_pcm_analog_playback
13024 #define alc861_pcm_analog_capture alc880_pcm_analog_capture
13025 #define alc861_pcm_digital_playback alc880_pcm_digital_playback
13026 #define alc861_pcm_digital_capture alc880_pcm_digital_capture
13029 #define ALC861_DIGOUT_NID 0x07
13031 static struct hda_channel_mode alc861_8ch_modes[1] = {
13035 static hda_nid_t alc861_dac_nids[4] = {
13036 /* front, surround, clfe, side */
13037 0x03, 0x06, 0x05, 0x04
13040 static hda_nid_t alc660_dac_nids[3] = {
13041 /* front, clfe, surround */
13045 static hda_nid_t alc861_adc_nids[1] = {
13050 static struct hda_input_mux alc861_capture_source = {
13054 { "Front Mic", 0x3 },
13061 /* fill in the dac_nids table from the parsed pin configuration */
13062 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13063 const struct auto_pin_cfg *cfg)
13068 spec->multiout.dac_nids = spec->private_dac_nids;
13069 for (i = 0; i < cfg->line_outs; i++) {
13070 nid = cfg->line_out_pins[i];
13072 if (i >= ARRAY_SIZE(alc861_dac_nids))
13074 spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13077 spec->multiout.num_dacs = cfg->line_outs;
13081 /* add playback controls from the parsed DAC table */
13082 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13083 const struct auto_pin_cfg *cfg)
13086 static const char *chname[4] = {
13087 "Front", "Surround", NULL /*CLFE*/, "Side"
13092 for (i = 0; i < cfg->line_outs; i++) {
13093 nid = spec->multiout.dac_nids[i];
13098 err = add_control(spec, ALC_CTL_BIND_MUTE,
13099 "Center Playback Switch",
13100 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13104 err = add_control(spec, ALC_CTL_BIND_MUTE,
13105 "LFE Playback Switch",
13106 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13111 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13113 if (nid == alc861_dac_nids[idx])
13115 sprintf(name, "%s Playback Switch", chname[idx]);
13116 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13117 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13126 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13134 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13136 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13137 "Headphone Playback Switch",
13138 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13141 spec->multiout.hp_nid = nid;
13146 /* create playback/capture controls for input pins */
13147 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13148 const struct auto_pin_cfg *cfg)
13150 struct hda_input_mux *imux = &spec->private_imux;
13151 int i, err, idx, idx1;
13153 for (i = 0; i < AUTO_PIN_LAST; i++) {
13154 switch (cfg->input_pins[i]) {
13157 idx = 2; /* Line In */
13161 idx = 2; /* Line In */
13165 idx = 1; /* Mic In */
13169 idx = 1; /* Mic In */
13179 err = new_analog_input(spec, cfg->input_pins[i],
13180 auto_pin_cfg_labels[i], idx, 0x15);
13184 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13185 imux->items[imux->num_items].index = idx1;
13191 static struct snd_kcontrol_new alc861_capture_mixer[] = {
13192 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13193 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13196 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13197 /* The multiple "Capture Source" controls confuse alsamixer
13198 * So call somewhat different..
13200 /* .name = "Capture Source", */
13201 .name = "Input Source",
13203 .info = alc_mux_enum_info,
13204 .get = alc_mux_enum_get,
13205 .put = alc_mux_enum_put,
13210 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13212 int pin_type, int dac_idx)
13214 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13216 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13220 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13222 struct alc_spec *spec = codec->spec;
13225 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13226 for (i = 0; i < spec->autocfg.line_outs; i++) {
13227 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13228 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13230 alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13231 spec->multiout.dac_nids[i]);
13235 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13237 struct alc_spec *spec = codec->spec;
13240 pin = spec->autocfg.hp_pins[0];
13241 if (pin) /* connect to front */
13242 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13243 spec->multiout.dac_nids[0]);
13244 pin = spec->autocfg.speaker_pins[0];
13246 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13249 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13251 struct alc_spec *spec = codec->spec;
13254 for (i = 0; i < AUTO_PIN_LAST; i++) {
13255 hda_nid_t nid = spec->autocfg.input_pins[i];
13256 if (nid >= 0x0c && nid <= 0x11) {
13257 snd_hda_codec_write(codec, nid, 0,
13258 AC_VERB_SET_PIN_WIDGET_CONTROL,
13259 i <= AUTO_PIN_FRONT_MIC ?
13260 PIN_VREF80 : PIN_IN);
13265 /* parse the BIOS configuration and set up the alc_spec */
13266 /* return 1 if successful, 0 if the proper config is not found,
13267 * or a negative error code
13269 static int alc861_parse_auto_config(struct hda_codec *codec)
13271 struct alc_spec *spec = codec->spec;
13273 static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13275 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13279 if (!spec->autocfg.line_outs)
13280 return 0; /* can't find valid BIOS pin config */
13282 err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13285 err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13288 err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13291 err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13295 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13297 if (spec->autocfg.dig_out_pin)
13298 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13300 if (spec->kctl_alloc)
13301 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13303 spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
13305 spec->num_mux_defs = 1;
13306 spec->input_mux = &spec->private_imux;
13308 spec->adc_nids = alc861_adc_nids;
13309 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13310 spec->mixers[spec->num_mixers] = alc861_capture_mixer;
13311 spec->num_mixers++;
13316 /* additional initialization for auto-configuration model */
13317 static void alc861_auto_init(struct hda_codec *codec)
13319 struct alc_spec *spec = codec->spec;
13320 alc861_auto_init_multi_out(codec);
13321 alc861_auto_init_hp_out(codec);
13322 alc861_auto_init_analog_input(codec);
13323 if (spec->unsol_event)
13324 alc_inithook(codec);
13327 #ifdef CONFIG_SND_HDA_POWER_SAVE
13328 static struct hda_amp_list alc861_loopbacks[] = {
13329 { 0x15, HDA_INPUT, 0 },
13330 { 0x15, HDA_INPUT, 1 },
13331 { 0x15, HDA_INPUT, 2 },
13332 { 0x15, HDA_INPUT, 3 },
13339 * configuration and preset
13341 static const char *alc861_models[ALC861_MODEL_LAST] = {
13342 [ALC861_3ST] = "3stack",
13343 [ALC660_3ST] = "3stack-660",
13344 [ALC861_3ST_DIG] = "3stack-dig",
13345 [ALC861_6ST_DIG] = "6stack-dig",
13346 [ALC861_UNIWILL_M31] = "uniwill-m31",
13347 [ALC861_TOSHIBA] = "toshiba",
13348 [ALC861_ASUS] = "asus",
13349 [ALC861_ASUS_LAPTOP] = "asus-laptop",
13350 [ALC861_AUTO] = "auto",
13353 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13354 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13355 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13356 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13357 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13358 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13359 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13360 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13361 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13362 * Any other models that need this preset?
13364 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13365 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13366 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13367 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13368 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13369 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13370 /* FIXME: the below seems conflict */
13371 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13372 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13373 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13377 static struct alc_config_preset alc861_presets[] = {
13379 .mixers = { alc861_3ST_mixer },
13380 .init_verbs = { alc861_threestack_init_verbs },
13381 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13382 .dac_nids = alc861_dac_nids,
13383 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13384 .channel_mode = alc861_threestack_modes,
13386 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13387 .adc_nids = alc861_adc_nids,
13388 .input_mux = &alc861_capture_source,
13390 [ALC861_3ST_DIG] = {
13391 .mixers = { alc861_base_mixer },
13392 .init_verbs = { alc861_threestack_init_verbs },
13393 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13394 .dac_nids = alc861_dac_nids,
13395 .dig_out_nid = ALC861_DIGOUT_NID,
13396 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13397 .channel_mode = alc861_threestack_modes,
13399 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13400 .adc_nids = alc861_adc_nids,
13401 .input_mux = &alc861_capture_source,
13403 [ALC861_6ST_DIG] = {
13404 .mixers = { alc861_base_mixer },
13405 .init_verbs = { alc861_base_init_verbs },
13406 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13407 .dac_nids = alc861_dac_nids,
13408 .dig_out_nid = ALC861_DIGOUT_NID,
13409 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13410 .channel_mode = alc861_8ch_modes,
13411 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13412 .adc_nids = alc861_adc_nids,
13413 .input_mux = &alc861_capture_source,
13416 .mixers = { alc861_3ST_mixer },
13417 .init_verbs = { alc861_threestack_init_verbs },
13418 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13419 .dac_nids = alc660_dac_nids,
13420 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13421 .channel_mode = alc861_threestack_modes,
13423 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13424 .adc_nids = alc861_adc_nids,
13425 .input_mux = &alc861_capture_source,
13427 [ALC861_UNIWILL_M31] = {
13428 .mixers = { alc861_uniwill_m31_mixer },
13429 .init_verbs = { alc861_uniwill_m31_init_verbs },
13430 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13431 .dac_nids = alc861_dac_nids,
13432 .dig_out_nid = ALC861_DIGOUT_NID,
13433 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
13434 .channel_mode = alc861_uniwill_m31_modes,
13436 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13437 .adc_nids = alc861_adc_nids,
13438 .input_mux = &alc861_capture_source,
13440 [ALC861_TOSHIBA] = {
13441 .mixers = { alc861_toshiba_mixer },
13442 .init_verbs = { alc861_base_init_verbs,
13443 alc861_toshiba_init_verbs },
13444 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13445 .dac_nids = alc861_dac_nids,
13446 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13447 .channel_mode = alc883_3ST_2ch_modes,
13448 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13449 .adc_nids = alc861_adc_nids,
13450 .input_mux = &alc861_capture_source,
13451 .unsol_event = alc861_toshiba_unsol_event,
13452 .init_hook = alc861_toshiba_automute,
13455 .mixers = { alc861_asus_mixer },
13456 .init_verbs = { alc861_asus_init_verbs },
13457 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13458 .dac_nids = alc861_dac_nids,
13459 .dig_out_nid = ALC861_DIGOUT_NID,
13460 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
13461 .channel_mode = alc861_asus_modes,
13464 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13465 .adc_nids = alc861_adc_nids,
13466 .input_mux = &alc861_capture_source,
13468 [ALC861_ASUS_LAPTOP] = {
13469 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
13470 .init_verbs = { alc861_asus_init_verbs,
13471 alc861_asus_laptop_init_verbs },
13472 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13473 .dac_nids = alc861_dac_nids,
13474 .dig_out_nid = ALC861_DIGOUT_NID,
13475 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13476 .channel_mode = alc883_3ST_2ch_modes,
13478 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13479 .adc_nids = alc861_adc_nids,
13480 .input_mux = &alc861_capture_source,
13485 static int patch_alc861(struct hda_codec *codec)
13487 struct alc_spec *spec;
13491 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13495 codec->spec = spec;
13497 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
13501 if (board_config < 0) {
13502 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
13503 "trying auto-probe from BIOS...\n");
13504 board_config = ALC861_AUTO;
13507 if (board_config == ALC861_AUTO) {
13508 /* automatic parse from the BIOS config */
13509 err = alc861_parse_auto_config(codec);
13515 "hda_codec: Cannot set up configuration "
13516 "from BIOS. Using base mode...\n");
13517 board_config = ALC861_3ST_DIG;
13521 if (board_config != ALC861_AUTO)
13522 setup_preset(spec, &alc861_presets[board_config]);
13524 spec->stream_name_analog = "ALC861 Analog";
13525 spec->stream_analog_playback = &alc861_pcm_analog_playback;
13526 spec->stream_analog_capture = &alc861_pcm_analog_capture;
13528 spec->stream_name_digital = "ALC861 Digital";
13529 spec->stream_digital_playback = &alc861_pcm_digital_playback;
13530 spec->stream_digital_capture = &alc861_pcm_digital_capture;
13532 spec->vmaster_nid = 0x03;
13534 codec->patch_ops = alc_patch_ops;
13535 if (board_config == ALC861_AUTO)
13536 spec->init_hook = alc861_auto_init;
13537 #ifdef CONFIG_SND_HDA_POWER_SAVE
13538 if (!spec->loopback.amplist)
13539 spec->loopback.amplist = alc861_loopbacks;
13546 * ALC861-VD support
13550 * In addition, an independent DAC
13552 #define ALC861VD_DIGOUT_NID 0x06
13554 static hda_nid_t alc861vd_dac_nids[4] = {
13555 /* front, surr, clfe, side surr */
13556 0x02, 0x03, 0x04, 0x05
13559 /* dac_nids for ALC660vd are in a different order - according to
13560 * Realtek's driver.
13561 * This should probably tesult in a different mixer for 6stack models
13562 * of ALC660vd codecs, but for now there is only 3stack mixer
13563 * - and it is the same as in 861vd.
13564 * adc_nids in ALC660vd are (is) the same as in 861vd
13566 static hda_nid_t alc660vd_dac_nids[3] = {
13567 /* front, rear, clfe, rear_surr */
13571 static hda_nid_t alc861vd_adc_nids[1] = {
13576 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
13579 /* FIXME: should be a matrix-type input source selection */
13580 static struct hda_input_mux alc861vd_capture_source = {
13584 { "Front Mic", 0x1 },
13590 static struct hda_input_mux alc861vd_dallas_capture_source = {
13593 { "Ext Mic", 0x0 },
13594 { "Int Mic", 0x1 },
13598 static struct hda_input_mux alc861vd_hp_capture_source = {
13601 { "Front Mic", 0x0 },
13602 { "ATAPI Mic", 0x1 },
13606 #define alc861vd_mux_enum_info alc_mux_enum_info
13607 #define alc861vd_mux_enum_get alc_mux_enum_get
13608 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
13609 #define alc861vd_mux_enum_put alc882_mux_enum_put
13614 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
13621 static struct hda_verb alc861vd_6stack_ch6_init[] = {
13622 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13623 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13624 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13625 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13632 static struct hda_verb alc861vd_6stack_ch8_init[] = {
13633 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13634 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13635 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13636 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13640 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
13641 { 6, alc861vd_6stack_ch6_init },
13642 { 8, alc861vd_6stack_ch8_init },
13645 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
13647 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13648 .name = "Channel Mode",
13649 .info = alc_ch_mode_info,
13650 .get = alc_ch_mode_get,
13651 .put = alc_ch_mode_put,
13656 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
13657 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13658 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13661 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13662 /* The multiple "Capture Source" controls confuse alsamixer
13663 * So call somewhat different..
13665 /* .name = "Capture Source", */
13666 .name = "Input Source",
13668 .info = alc861vd_mux_enum_info,
13669 .get = alc861vd_mux_enum_get,
13670 .put = alc861vd_mux_enum_put,
13675 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13676 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13678 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
13679 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13680 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13682 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13683 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
13685 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
13687 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
13689 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13690 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
13692 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
13693 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
13695 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13697 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13698 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13699 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13701 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13702 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13703 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13705 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13706 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13708 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13709 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13711 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13712 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13717 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
13718 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13719 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13721 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13723 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13724 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13725 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13727 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13728 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13729 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13731 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13732 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13734 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13735 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13737 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13738 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13743 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
13744 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13745 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
13746 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13748 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13750 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13751 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13752 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13754 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13755 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13756 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13758 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13759 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13764 /* Pin assignment: Speaker=0x14, HP = 0x15,
13765 * Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
13767 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
13768 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13769 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
13770 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13771 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13772 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13773 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13774 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13775 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13776 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13777 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13778 HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
13779 HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
13783 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
13784 * Front Mic=0x18, ATAPI Mic = 0x19,
13786 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
13787 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13788 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13789 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13790 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13791 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13792 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13793 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13794 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13800 * generic initialization of ADC, input mixers and output mixers
13802 static struct hda_verb alc861vd_volume_init_verbs[] = {
13804 * Unmute ADC0 and set the default input to mic-in
13806 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13807 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13809 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
13810 * the analog-loopback mixer widget
13812 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13813 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13814 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13815 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13816 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13817 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13819 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
13820 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13821 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13822 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13823 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13826 * Set up output mixers (0x02 - 0x05)
13828 /* set vol=0 to output mixers */
13829 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13830 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13831 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13832 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13834 /* set up input amps for analog loopback */
13835 /* Amp Indices: DAC = 0, mixer = 1 */
13836 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13837 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13838 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13839 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13840 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13841 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13842 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13843 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13849 * 3-stack pin configuration:
13850 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
13852 static struct hda_verb alc861vd_3stack_init_verbs[] = {
13854 * Set pin mode and muting
13856 /* set front pin widgets 0x14 for output */
13857 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13858 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13859 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13861 /* Mic (rear) pin: input vref at 80% */
13862 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13863 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13864 /* Front Mic pin: input vref at 80% */
13865 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13866 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13867 /* Line In pin: input */
13868 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13869 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13870 /* Line-2 In: Headphone output (output 0 - 0x0c) */
13871 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13872 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13873 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13874 /* CD pin widget for input */
13875 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13881 * 6-stack pin configuration:
13883 static struct hda_verb alc861vd_6stack_init_verbs[] = {
13885 * Set pin mode and muting
13887 /* set front pin widgets 0x14 for output */
13888 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13889 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13890 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13892 /* Rear Pin: output 1 (0x0d) */
13893 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13894 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13895 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13896 /* CLFE Pin: output 2 (0x0e) */
13897 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13898 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13899 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
13900 /* Side Pin: output 3 (0x0f) */
13901 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13902 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13903 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
13905 /* Mic (rear) pin: input vref at 80% */
13906 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13907 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13908 /* Front Mic pin: input vref at 80% */
13909 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13910 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13911 /* Line In pin: input */
13912 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13913 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13914 /* Line-2 In: Headphone output (output 0 - 0x0c) */
13915 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13916 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13917 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13918 /* CD pin widget for input */
13919 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13924 static struct hda_verb alc861vd_eapd_verbs[] = {
13925 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13929 static struct hda_verb alc660vd_eapd_verbs[] = {
13930 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13931 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13935 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
13936 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13937 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13938 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
13939 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13940 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13944 /* toggle speaker-output according to the hp-jack state */
13945 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
13947 unsigned int present;
13948 unsigned char bits;
13950 present = snd_hda_codec_read(codec, 0x1b, 0,
13951 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13952 bits = present ? HDA_AMP_MUTE : 0;
13953 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13954 HDA_AMP_MUTE, bits);
13957 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
13959 unsigned int present;
13960 unsigned char bits;
13962 present = snd_hda_codec_read(codec, 0x18, 0,
13963 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13964 bits = present ? HDA_AMP_MUTE : 0;
13965 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
13966 HDA_AMP_MUTE, bits);
13969 static void alc861vd_lenovo_automute(struct hda_codec *codec)
13971 alc861vd_lenovo_hp_automute(codec);
13972 alc861vd_lenovo_mic_automute(codec);
13975 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
13978 switch (res >> 26) {
13979 case ALC880_HP_EVENT:
13980 alc861vd_lenovo_hp_automute(codec);
13982 case ALC880_MIC_EVENT:
13983 alc861vd_lenovo_mic_automute(codec);
13988 static struct hda_verb alc861vd_dallas_verbs[] = {
13989 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13990 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13991 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13992 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13994 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13995 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13996 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13997 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13998 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13999 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14000 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14001 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14003 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14004 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14005 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14006 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14007 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14008 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14009 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14010 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14012 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14013 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14014 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14015 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14016 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14017 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14018 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14019 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14021 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14022 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14023 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14024 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14026 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14027 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14028 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14033 /* toggle speaker-output according to the hp-jack state */
14034 static void alc861vd_dallas_automute(struct hda_codec *codec)
14036 unsigned int present;
14038 present = snd_hda_codec_read(codec, 0x15, 0,
14039 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14040 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14041 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14044 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14046 if ((res >> 26) == ALC880_HP_EVENT)
14047 alc861vd_dallas_automute(codec);
14050 #ifdef CONFIG_SND_HDA_POWER_SAVE
14051 #define alc861vd_loopbacks alc880_loopbacks
14054 /* pcm configuration: identiacal with ALC880 */
14055 #define alc861vd_pcm_analog_playback alc880_pcm_analog_playback
14056 #define alc861vd_pcm_analog_capture alc880_pcm_analog_capture
14057 #define alc861vd_pcm_digital_playback alc880_pcm_digital_playback
14058 #define alc861vd_pcm_digital_capture alc880_pcm_digital_capture
14061 * configuration and preset
14063 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14064 [ALC660VD_3ST] = "3stack-660",
14065 [ALC660VD_3ST_DIG] = "3stack-660-digout",
14066 [ALC861VD_3ST] = "3stack",
14067 [ALC861VD_3ST_DIG] = "3stack-digout",
14068 [ALC861VD_6ST_DIG] = "6stack-digout",
14069 [ALC861VD_LENOVO] = "lenovo",
14070 [ALC861VD_DALLAS] = "dallas",
14071 [ALC861VD_HP] = "hp",
14072 [ALC861VD_AUTO] = "auto",
14075 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14076 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14077 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14078 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14079 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14080 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
14081 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14082 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14083 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14084 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14085 SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14086 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14087 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14088 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14089 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
14090 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
14091 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
14092 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14096 static struct alc_config_preset alc861vd_presets[] = {
14098 .mixers = { alc861vd_3st_mixer },
14099 .init_verbs = { alc861vd_volume_init_verbs,
14100 alc861vd_3stack_init_verbs },
14101 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14102 .dac_nids = alc660vd_dac_nids,
14103 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14104 .channel_mode = alc861vd_3stack_2ch_modes,
14105 .input_mux = &alc861vd_capture_source,
14107 [ALC660VD_3ST_DIG] = {
14108 .mixers = { alc861vd_3st_mixer },
14109 .init_verbs = { alc861vd_volume_init_verbs,
14110 alc861vd_3stack_init_verbs },
14111 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14112 .dac_nids = alc660vd_dac_nids,
14113 .dig_out_nid = ALC861VD_DIGOUT_NID,
14114 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14115 .channel_mode = alc861vd_3stack_2ch_modes,
14116 .input_mux = &alc861vd_capture_source,
14119 .mixers = { alc861vd_3st_mixer },
14120 .init_verbs = { alc861vd_volume_init_verbs,
14121 alc861vd_3stack_init_verbs },
14122 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14123 .dac_nids = alc861vd_dac_nids,
14124 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14125 .channel_mode = alc861vd_3stack_2ch_modes,
14126 .input_mux = &alc861vd_capture_source,
14128 [ALC861VD_3ST_DIG] = {
14129 .mixers = { alc861vd_3st_mixer },
14130 .init_verbs = { alc861vd_volume_init_verbs,
14131 alc861vd_3stack_init_verbs },
14132 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14133 .dac_nids = alc861vd_dac_nids,
14134 .dig_out_nid = ALC861VD_DIGOUT_NID,
14135 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14136 .channel_mode = alc861vd_3stack_2ch_modes,
14137 .input_mux = &alc861vd_capture_source,
14139 [ALC861VD_6ST_DIG] = {
14140 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14141 .init_verbs = { alc861vd_volume_init_verbs,
14142 alc861vd_6stack_init_verbs },
14143 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14144 .dac_nids = alc861vd_dac_nids,
14145 .dig_out_nid = ALC861VD_DIGOUT_NID,
14146 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14147 .channel_mode = alc861vd_6stack_modes,
14148 .input_mux = &alc861vd_capture_source,
14150 [ALC861VD_LENOVO] = {
14151 .mixers = { alc861vd_lenovo_mixer },
14152 .init_verbs = { alc861vd_volume_init_verbs,
14153 alc861vd_3stack_init_verbs,
14154 alc861vd_eapd_verbs,
14155 alc861vd_lenovo_unsol_verbs },
14156 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14157 .dac_nids = alc660vd_dac_nids,
14158 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14159 .channel_mode = alc861vd_3stack_2ch_modes,
14160 .input_mux = &alc861vd_capture_source,
14161 .unsol_event = alc861vd_lenovo_unsol_event,
14162 .init_hook = alc861vd_lenovo_automute,
14164 [ALC861VD_DALLAS] = {
14165 .mixers = { alc861vd_dallas_mixer },
14166 .init_verbs = { alc861vd_dallas_verbs },
14167 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14168 .dac_nids = alc861vd_dac_nids,
14169 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14170 .channel_mode = alc861vd_3stack_2ch_modes,
14171 .input_mux = &alc861vd_dallas_capture_source,
14172 .unsol_event = alc861vd_dallas_unsol_event,
14173 .init_hook = alc861vd_dallas_automute,
14176 .mixers = { alc861vd_hp_mixer },
14177 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14178 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14179 .dac_nids = alc861vd_dac_nids,
14180 .dig_out_nid = ALC861VD_DIGOUT_NID,
14181 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14182 .channel_mode = alc861vd_3stack_2ch_modes,
14183 .input_mux = &alc861vd_hp_capture_source,
14184 .unsol_event = alc861vd_dallas_unsol_event,
14185 .init_hook = alc861vd_dallas_automute,
14190 * BIOS auto configuration
14192 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14193 hda_nid_t nid, int pin_type, int dac_idx)
14195 alc_set_pin_output(codec, nid, pin_type);
14198 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14200 struct alc_spec *spec = codec->spec;
14203 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14204 for (i = 0; i <= HDA_SIDE; i++) {
14205 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14206 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14208 alc861vd_auto_set_output_and_unmute(codec, nid,
14214 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14216 struct alc_spec *spec = codec->spec;
14219 pin = spec->autocfg.hp_pins[0];
14220 if (pin) /* connect to front and use dac 0 */
14221 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14222 pin = spec->autocfg.speaker_pins[0];
14224 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14227 #define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid)
14228 #define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID
14230 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14232 struct alc_spec *spec = codec->spec;
14235 for (i = 0; i < AUTO_PIN_LAST; i++) {
14236 hda_nid_t nid = spec->autocfg.input_pins[i];
14237 if (alc861vd_is_input_pin(nid)) {
14238 snd_hda_codec_write(codec, nid, 0,
14239 AC_VERB_SET_PIN_WIDGET_CONTROL,
14240 i <= AUTO_PIN_FRONT_MIC ?
14241 PIN_VREF80 : PIN_IN);
14242 if (nid != ALC861VD_PIN_CD_NID)
14243 snd_hda_codec_write(codec, nid, 0,
14244 AC_VERB_SET_AMP_GAIN_MUTE,
14250 #define alc861vd_auto_init_input_src alc882_auto_init_input_src
14252 #define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02)
14253 #define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c)
14255 /* add playback controls from the parsed DAC table */
14256 /* Based on ALC880 version. But ALC861VD has separate,
14257 * different NIDs for mute/unmute switch and volume control */
14258 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14259 const struct auto_pin_cfg *cfg)
14262 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14263 hda_nid_t nid_v, nid_s;
14266 for (i = 0; i < cfg->line_outs; i++) {
14267 if (!spec->multiout.dac_nids[i])
14269 nid_v = alc861vd_idx_to_mixer_vol(
14271 spec->multiout.dac_nids[i]));
14272 nid_s = alc861vd_idx_to_mixer_switch(
14274 spec->multiout.dac_nids[i]));
14278 err = add_control(spec, ALC_CTL_WIDGET_VOL,
14279 "Center Playback Volume",
14280 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14284 err = add_control(spec, ALC_CTL_WIDGET_VOL,
14285 "LFE Playback Volume",
14286 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14290 err = add_control(spec, ALC_CTL_BIND_MUTE,
14291 "Center Playback Switch",
14292 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14296 err = add_control(spec, ALC_CTL_BIND_MUTE,
14297 "LFE Playback Switch",
14298 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14303 sprintf(name, "%s Playback Volume", chname[i]);
14304 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14305 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14309 sprintf(name, "%s Playback Switch", chname[i]);
14310 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14311 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14320 /* add playback controls for speaker and HP outputs */
14321 /* Based on ALC880 version. But ALC861VD has separate,
14322 * different NIDs for mute/unmute switch and volume control */
14323 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14324 hda_nid_t pin, const char *pfx)
14326 hda_nid_t nid_v, nid_s;
14333 if (alc880_is_fixed_pin(pin)) {
14334 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14335 /* specify the DAC as the extra output */
14336 if (!spec->multiout.hp_nid)
14337 spec->multiout.hp_nid = nid_v;
14339 spec->multiout.extra_out_nid[0] = nid_v;
14340 /* control HP volume/switch on the output mixer amp */
14341 nid_v = alc861vd_idx_to_mixer_vol(
14342 alc880_fixed_pin_idx(pin));
14343 nid_s = alc861vd_idx_to_mixer_switch(
14344 alc880_fixed_pin_idx(pin));
14346 sprintf(name, "%s Playback Volume", pfx);
14347 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14348 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14351 sprintf(name, "%s Playback Switch", pfx);
14352 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14353 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14356 } else if (alc880_is_multi_pin(pin)) {
14357 /* set manual connection */
14358 /* we have only a switch on HP-out PIN */
14359 sprintf(name, "%s Playback Switch", pfx);
14360 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14361 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14368 /* parse the BIOS configuration and set up the alc_spec
14369 * return 1 if successful, 0 if the proper config is not found,
14370 * or a negative error code
14371 * Based on ALC880 version - had to change it to override
14372 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14373 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14375 struct alc_spec *spec = codec->spec;
14377 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14379 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14383 if (!spec->autocfg.line_outs)
14384 return 0; /* can't find valid BIOS pin config */
14386 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14389 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14392 err = alc861vd_auto_create_extra_out(spec,
14393 spec->autocfg.speaker_pins[0],
14397 err = alc861vd_auto_create_extra_out(spec,
14398 spec->autocfg.hp_pins[0],
14402 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14406 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14408 if (spec->autocfg.dig_out_pin)
14409 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14411 if (spec->kctl_alloc)
14412 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14414 spec->init_verbs[spec->num_init_verbs++]
14415 = alc861vd_volume_init_verbs;
14417 spec->num_mux_defs = 1;
14418 spec->input_mux = &spec->private_imux;
14420 err = alc_auto_add_mic_boost(codec);
14427 /* additional initialization for auto-configuration model */
14428 static void alc861vd_auto_init(struct hda_codec *codec)
14430 struct alc_spec *spec = codec->spec;
14431 alc861vd_auto_init_multi_out(codec);
14432 alc861vd_auto_init_hp_out(codec);
14433 alc861vd_auto_init_analog_input(codec);
14434 alc861vd_auto_init_input_src(codec);
14435 if (spec->unsol_event)
14436 alc_inithook(codec);
14439 static int patch_alc861vd(struct hda_codec *codec)
14441 struct alc_spec *spec;
14442 int err, board_config;
14444 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14448 codec->spec = spec;
14450 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
14454 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
14455 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
14456 "ALC861VD, trying auto-probe from BIOS...\n");
14457 board_config = ALC861VD_AUTO;
14460 if (board_config == ALC861VD_AUTO) {
14461 /* automatic parse from the BIOS config */
14462 err = alc861vd_parse_auto_config(codec);
14468 "hda_codec: Cannot set up configuration "
14469 "from BIOS. Using base mode...\n");
14470 board_config = ALC861VD_3ST;
14474 if (board_config != ALC861VD_AUTO)
14475 setup_preset(spec, &alc861vd_presets[board_config]);
14477 if (codec->vendor_id == 0x10ec0660) {
14478 spec->stream_name_analog = "ALC660-VD Analog";
14479 spec->stream_name_digital = "ALC660-VD Digital";
14480 /* always turn on EAPD */
14481 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
14483 spec->stream_name_analog = "ALC861VD Analog";
14484 spec->stream_name_digital = "ALC861VD Digital";
14487 spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
14488 spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
14490 spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
14491 spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
14493 spec->adc_nids = alc861vd_adc_nids;
14494 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
14495 spec->capsrc_nids = alc861vd_capsrc_nids;
14497 spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
14498 spec->num_mixers++;
14500 spec->vmaster_nid = 0x02;
14502 codec->patch_ops = alc_patch_ops;
14504 if (board_config == ALC861VD_AUTO)
14505 spec->init_hook = alc861vd_auto_init;
14506 #ifdef CONFIG_SND_HDA_POWER_SAVE
14507 if (!spec->loopback.amplist)
14508 spec->loopback.amplist = alc861vd_loopbacks;
14517 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
14518 * configuration. Each pin widget can choose any input DACs and a mixer.
14519 * Each ADC is connected from a mixer of all inputs. This makes possible
14520 * 6-channel independent captures.
14522 * In addition, an independent DAC for the multi-playback (not used in this
14525 #define ALC662_DIGOUT_NID 0x06
14526 #define ALC662_DIGIN_NID 0x0a
14528 static hda_nid_t alc662_dac_nids[4] = {
14529 /* front, rear, clfe, rear_surr */
14533 static hda_nid_t alc662_adc_nids[1] = {
14538 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
14541 /* FIXME: should be a matrix-type input source selection */
14542 static struct hda_input_mux alc662_capture_source = {
14546 { "Front Mic", 0x1 },
14552 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
14560 static struct hda_input_mux alc662_eeepc_capture_source = {
14568 static struct hda_input_mux alc663_capture_source = {
14572 { "Front Mic", 0x1 },
14577 static struct hda_input_mux alc663_m51va_capture_source = {
14580 { "Ext-Mic", 0x0 },
14585 #define alc662_mux_enum_info alc_mux_enum_info
14586 #define alc662_mux_enum_get alc_mux_enum_get
14587 #define alc662_mux_enum_put alc882_mux_enum_put
14592 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
14599 static struct hda_verb alc662_3ST_ch2_init[] = {
14600 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
14601 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14602 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
14603 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14610 static struct hda_verb alc662_3ST_ch6_init[] = {
14611 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14612 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14613 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
14614 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14615 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14616 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
14620 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
14621 { 2, alc662_3ST_ch2_init },
14622 { 6, alc662_3ST_ch6_init },
14628 static struct hda_verb alc662_sixstack_ch6_init[] = {
14629 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14630 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14631 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14638 static struct hda_verb alc662_sixstack_ch8_init[] = {
14639 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14640 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14641 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14645 static struct hda_channel_mode alc662_5stack_modes[2] = {
14646 { 2, alc662_sixstack_ch6_init },
14647 { 6, alc662_sixstack_ch8_init },
14650 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14651 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14654 static struct snd_kcontrol_new alc662_base_mixer[] = {
14655 /* output mixer control */
14656 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
14657 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14658 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
14659 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14660 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14661 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14662 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14663 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14664 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14666 /*Input mixer control */
14667 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
14668 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
14669 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
14670 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
14671 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
14672 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
14673 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
14674 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
14678 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
14679 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14680 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14681 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14682 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14683 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14684 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14685 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14686 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14687 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14688 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14689 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14690 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14691 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14695 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
14696 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14697 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14698 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14699 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14700 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14701 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14702 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14703 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14704 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14705 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14706 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14707 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14708 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14709 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14710 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14711 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14712 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14713 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14714 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14718 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
14719 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14720 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
14721 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14722 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
14723 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14724 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14725 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14726 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14727 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14731 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
14732 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14734 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14735 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14737 HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
14738 HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14739 HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14741 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
14742 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14743 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14747 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
14748 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14749 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14750 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14751 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
14752 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14753 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14754 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
14755 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
14756 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14757 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
14758 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14759 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14760 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14761 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14765 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
14766 .ops = &snd_hda_bind_vol,
14768 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14769 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
14774 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
14775 .ops = &snd_hda_bind_sw,
14777 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14778 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14783 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
14784 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14785 HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
14786 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14787 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14791 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
14792 .ops = &snd_hda_bind_sw,
14794 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14795 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14796 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14801 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
14802 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14803 HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
14804 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14805 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14806 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14807 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14812 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
14813 .ops = &snd_hda_bind_sw,
14815 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14816 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14817 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
14822 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
14823 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14824 HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
14825 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14826 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14827 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14828 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14832 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
14833 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14834 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14835 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14836 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14837 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14838 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14839 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14843 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
14844 .ops = &snd_hda_bind_vol,
14846 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14847 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
14852 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
14853 .ops = &snd_hda_bind_sw,
14855 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14856 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
14861 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
14862 HDA_BIND_VOL("Master Playback Volume",
14863 &alc663_asus_two_bind_master_vol),
14864 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14865 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14866 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14867 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14868 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14872 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
14873 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14874 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14875 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14876 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14877 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14878 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14882 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
14883 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14884 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14885 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14886 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14887 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14889 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14890 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14891 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14892 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14896 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
14897 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14898 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14899 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14901 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14902 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14903 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14904 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14905 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14906 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14910 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
14912 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14913 .name = "Channel Mode",
14914 .info = alc_ch_mode_info,
14915 .get = alc_ch_mode_get,
14916 .put = alc_ch_mode_put,
14921 static struct hda_verb alc662_init_verbs[] = {
14922 /* ADC: mute amp left and right */
14923 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14924 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14925 /* Front mixer: unmute input/output amp left and right (volume = 0) */
14927 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14928 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14929 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14930 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14931 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14933 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14934 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14935 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14936 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14937 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14938 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14940 /* Front Pin: output 0 (0x0c) */
14941 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14942 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14944 /* Rear Pin: output 1 (0x0d) */
14945 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14946 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14948 /* CLFE Pin: output 2 (0x0e) */
14949 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14950 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14952 /* Mic (rear) pin: input vref at 80% */
14953 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14954 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14955 /* Front Mic pin: input vref at 80% */
14956 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14957 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14958 /* Line In pin: input */
14959 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14960 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14961 /* Line-2 In: Headphone output (output 0 - 0x0c) */
14962 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14963 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14964 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14965 /* CD pin widget for input */
14966 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14968 /* FIXME: use matrix-type input source selection */
14969 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
14971 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14972 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14973 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14974 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14976 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14977 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14978 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14979 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14981 /* always trun on EAPD */
14982 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14983 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14988 static struct hda_verb alc662_sue_init_verbs[] = {
14989 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
14990 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
14994 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
14995 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14996 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15000 /* Set Unsolicited Event*/
15001 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15002 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15003 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15008 * generic initialization of ADC, input mixers and output mixers
15010 static struct hda_verb alc662_auto_init_verbs[] = {
15012 * Unmute ADC and set the default input to mic-in
15014 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15015 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15017 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15019 * Note: PASD motherboards uses the Line In 2 as the input for front
15020 * panel mic (mic 2)
15022 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15023 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15024 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15025 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15026 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15027 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15030 * Set up output mixers (0x0c - 0x0f)
15032 /* set vol=0 to output mixers */
15033 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15034 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15035 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15037 /* set up input amps for analog loopback */
15038 /* Amp Indices: DAC = 0, mixer = 1 */
15039 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15040 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15041 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15042 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15043 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15044 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15047 /* FIXME: use matrix-type input source selection */
15048 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15050 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15051 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15055 /* additional verbs for ALC663 */
15056 static struct hda_verb alc663_auto_init_verbs[] = {
15057 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15058 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15062 static struct hda_verb alc663_m51va_init_verbs[] = {
15063 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15064 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15065 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15066 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15067 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15068 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15069 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15070 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15071 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15075 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15076 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15077 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15078 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15079 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15080 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15081 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15082 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15086 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15087 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15088 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15089 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15090 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
15091 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15092 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15093 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15094 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15098 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15099 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15100 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15101 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15102 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15103 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15104 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15105 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15109 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15110 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15111 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15112 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15113 {0x21, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */
15114 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15115 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15116 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */
15117 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15118 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15119 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15120 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15121 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15125 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15126 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15127 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15128 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15129 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15130 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15131 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15132 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15133 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15134 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15135 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15136 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15137 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15141 static struct hda_verb alc663_g71v_init_verbs[] = {
15142 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15143 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15144 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15146 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15147 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15148 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
15150 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15151 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15152 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15156 static struct hda_verb alc663_g50v_init_verbs[] = {
15157 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15158 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15159 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
15161 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15162 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15166 static struct hda_verb alc662_ecs_init_verbs[] = {
15167 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15168 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15169 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15170 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15174 /* capture mixer elements */
15175 static struct snd_kcontrol_new alc662_capture_mixer[] = {
15176 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15177 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15179 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15180 /* The multiple "Capture Source" controls confuse alsamixer
15181 * So call somewhat different..
15183 /* .name = "Capture Source", */
15184 .name = "Input Source",
15186 .info = alc662_mux_enum_info,
15187 .get = alc662_mux_enum_get,
15188 .put = alc662_mux_enum_put,
15193 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15194 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15195 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15199 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15201 unsigned int present;
15202 unsigned char bits;
15204 present = snd_hda_codec_read(codec, 0x14, 0,
15205 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15206 bits = present ? HDA_AMP_MUTE : 0;
15207 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15208 HDA_AMP_MUTE, bits);
15211 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15213 unsigned int present;
15214 unsigned char bits;
15216 present = snd_hda_codec_read(codec, 0x1b, 0,
15217 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15218 bits = present ? HDA_AMP_MUTE : 0;
15219 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15220 HDA_AMP_MUTE, bits);
15221 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15222 HDA_AMP_MUTE, bits);
15225 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15228 if ((res >> 26) == ALC880_HP_EVENT)
15229 alc662_lenovo_101e_all_automute(codec);
15230 if ((res >> 26) == ALC880_FRONT_EVENT)
15231 alc662_lenovo_101e_ispeaker_automute(codec);
15234 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15236 unsigned int present;
15238 present = snd_hda_codec_read(codec, 0x18, 0,
15239 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15240 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15241 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15242 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15243 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15244 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15245 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15246 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15247 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15250 /* unsolicited event for HP jack sensing */
15251 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15254 if ((res >> 26) == ALC880_HP_EVENT)
15255 alc262_hippo1_automute( codec );
15257 if ((res >> 26) == ALC880_MIC_EVENT)
15258 alc662_eeepc_mic_automute(codec);
15261 static void alc662_eeepc_inithook(struct hda_codec *codec)
15263 alc262_hippo1_automute( codec );
15264 alc662_eeepc_mic_automute(codec);
15267 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15270 unsigned int present;
15272 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15273 present = snd_hda_codec_read(codec, 0x14, 0,
15274 AC_VERB_GET_PIN_SENSE, 0);
15275 present = (present & 0x80000000) != 0;
15277 /* mute internal speaker */
15278 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15279 HDA_AMP_MUTE, HDA_AMP_MUTE);
15281 /* unmute internal speaker if necessary */
15282 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15283 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15284 HDA_AMP_MUTE, mute);
15288 /* unsolicited event for HP jack sensing */
15289 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15292 if ((res >> 26) == ALC880_HP_EVENT)
15293 alc662_eeepc_ep20_automute(codec);
15296 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15298 alc662_eeepc_ep20_automute(codec);
15301 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15303 unsigned int present;
15304 unsigned char bits;
15306 present = snd_hda_codec_read(codec, 0x21, 0,
15307 AC_VERB_GET_PIN_SENSE, 0)
15308 & AC_PINSENSE_PRESENCE;
15309 bits = present ? HDA_AMP_MUTE : 0;
15310 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15311 AMP_IN_MUTE(0), bits);
15312 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15313 AMP_IN_MUTE(0), bits);
15316 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15318 unsigned int present;
15319 unsigned char bits;
15321 present = snd_hda_codec_read(codec, 0x21, 0,
15322 AC_VERB_GET_PIN_SENSE, 0)
15323 & AC_PINSENSE_PRESENCE;
15324 bits = present ? HDA_AMP_MUTE : 0;
15325 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15326 AMP_IN_MUTE(0), bits);
15327 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15328 AMP_IN_MUTE(0), bits);
15329 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15330 AMP_IN_MUTE(0), bits);
15331 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15332 AMP_IN_MUTE(0), bits);
15335 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15337 unsigned int present;
15338 unsigned char bits;
15340 present = snd_hda_codec_read(codec, 0x15, 0,
15341 AC_VERB_GET_PIN_SENSE, 0)
15342 & AC_PINSENSE_PRESENCE;
15343 bits = present ? HDA_AMP_MUTE : 0;
15344 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15345 AMP_IN_MUTE(0), bits);
15346 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15347 AMP_IN_MUTE(0), bits);
15348 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15349 AMP_IN_MUTE(0), bits);
15350 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15351 AMP_IN_MUTE(0), bits);
15354 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15356 unsigned int present;
15357 unsigned char bits;
15359 present = snd_hda_codec_read(codec, 0x1b, 0,
15360 AC_VERB_GET_PIN_SENSE, 0)
15361 & AC_PINSENSE_PRESENCE;
15362 bits = present ? 0 : PIN_OUT;
15363 snd_hda_codec_write(codec, 0x14, 0,
15364 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15367 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15369 unsigned int present1, present2;
15371 present1 = snd_hda_codec_read(codec, 0x21, 0,
15372 AC_VERB_GET_PIN_SENSE, 0)
15373 & AC_PINSENSE_PRESENCE;
15374 present2 = snd_hda_codec_read(codec, 0x15, 0,
15375 AC_VERB_GET_PIN_SENSE, 0)
15376 & AC_PINSENSE_PRESENCE;
15378 if (present1 || present2) {
15379 snd_hda_codec_write_cache(codec, 0x14, 0,
15380 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15382 snd_hda_codec_write_cache(codec, 0x14, 0,
15383 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15387 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15389 unsigned int present1, present2;
15391 present1 = snd_hda_codec_read(codec, 0x1b, 0,
15392 AC_VERB_GET_PIN_SENSE, 0)
15393 & AC_PINSENSE_PRESENCE;
15394 present2 = snd_hda_codec_read(codec, 0x15, 0,
15395 AC_VERB_GET_PIN_SENSE, 0)
15396 & AC_PINSENSE_PRESENCE;
15398 if (present1 || present2) {
15399 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15400 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15401 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15402 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15404 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15405 AMP_IN_MUTE(0), 0);
15406 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15407 AMP_IN_MUTE(0), 0);
15411 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15413 unsigned int present;
15415 present = snd_hda_codec_read(codec, 0x18, 0,
15416 AC_VERB_GET_PIN_SENSE, 0)
15417 & AC_PINSENSE_PRESENCE;
15418 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15419 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15420 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15421 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15422 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15423 0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15424 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15425 0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15428 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15431 switch (res >> 26) {
15432 case ALC880_HP_EVENT:
15433 alc663_m51va_speaker_automute(codec);
15435 case ALC880_MIC_EVENT:
15436 alc663_m51va_mic_automute(codec);
15441 static void alc663_m51va_inithook(struct hda_codec *codec)
15443 alc663_m51va_speaker_automute(codec);
15444 alc663_m51va_mic_automute(codec);
15447 /* ***************** Mode1 ******************************/
15448 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15451 switch (res >> 26) {
15452 case ALC880_HP_EVENT:
15453 alc663_m51va_speaker_automute(codec);
15455 case ALC880_MIC_EVENT:
15456 alc662_eeepc_mic_automute(codec);
15461 static void alc663_mode1_inithook(struct hda_codec *codec)
15463 alc663_m51va_speaker_automute(codec);
15464 alc662_eeepc_mic_automute(codec);
15466 /* ***************** Mode2 ******************************/
15467 static void alc662_mode2_unsol_event(struct hda_codec *codec,
15470 switch (res >> 26) {
15471 case ALC880_HP_EVENT:
15472 alc662_f5z_speaker_automute(codec);
15474 case ALC880_MIC_EVENT:
15475 alc662_eeepc_mic_automute(codec);
15480 static void alc662_mode2_inithook(struct hda_codec *codec)
15482 alc662_f5z_speaker_automute(codec);
15483 alc662_eeepc_mic_automute(codec);
15485 /* ***************** Mode3 ******************************/
15486 static void alc663_mode3_unsol_event(struct hda_codec *codec,
15489 switch (res >> 26) {
15490 case ALC880_HP_EVENT:
15491 alc663_two_hp_m1_speaker_automute(codec);
15493 case ALC880_MIC_EVENT:
15494 alc662_eeepc_mic_automute(codec);
15499 static void alc663_mode3_inithook(struct hda_codec *codec)
15501 alc663_two_hp_m1_speaker_automute(codec);
15502 alc662_eeepc_mic_automute(codec);
15504 /* ***************** Mode4 ******************************/
15505 static void alc663_mode4_unsol_event(struct hda_codec *codec,
15508 switch (res >> 26) {
15509 case ALC880_HP_EVENT:
15510 alc663_21jd_two_speaker_automute(codec);
15512 case ALC880_MIC_EVENT:
15513 alc662_eeepc_mic_automute(codec);
15518 static void alc663_mode4_inithook(struct hda_codec *codec)
15520 alc663_21jd_two_speaker_automute(codec);
15521 alc662_eeepc_mic_automute(codec);
15523 /* ***************** Mode5 ******************************/
15524 static void alc663_mode5_unsol_event(struct hda_codec *codec,
15527 switch (res >> 26) {
15528 case ALC880_HP_EVENT:
15529 alc663_15jd_two_speaker_automute(codec);
15531 case ALC880_MIC_EVENT:
15532 alc662_eeepc_mic_automute(codec);
15537 static void alc663_mode5_inithook(struct hda_codec *codec)
15539 alc663_15jd_two_speaker_automute(codec);
15540 alc662_eeepc_mic_automute(codec);
15542 /* ***************** Mode6 ******************************/
15543 static void alc663_mode6_unsol_event(struct hda_codec *codec,
15546 switch (res >> 26) {
15547 case ALC880_HP_EVENT:
15548 alc663_two_hp_m2_speaker_automute(codec);
15550 case ALC880_MIC_EVENT:
15551 alc662_eeepc_mic_automute(codec);
15556 static void alc663_mode6_inithook(struct hda_codec *codec)
15558 alc663_two_hp_m2_speaker_automute(codec);
15559 alc662_eeepc_mic_automute(codec);
15562 static void alc663_g71v_hp_automute(struct hda_codec *codec)
15564 unsigned int present;
15565 unsigned char bits;
15567 present = snd_hda_codec_read(codec, 0x21, 0,
15568 AC_VERB_GET_PIN_SENSE, 0)
15569 & AC_PINSENSE_PRESENCE;
15570 bits = present ? HDA_AMP_MUTE : 0;
15571 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15572 HDA_AMP_MUTE, bits);
15573 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15574 HDA_AMP_MUTE, bits);
15577 static void alc663_g71v_front_automute(struct hda_codec *codec)
15579 unsigned int present;
15580 unsigned char bits;
15582 present = snd_hda_codec_read(codec, 0x15, 0,
15583 AC_VERB_GET_PIN_SENSE, 0)
15584 & AC_PINSENSE_PRESENCE;
15585 bits = present ? HDA_AMP_MUTE : 0;
15586 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15587 HDA_AMP_MUTE, bits);
15590 static void alc663_g71v_unsol_event(struct hda_codec *codec,
15593 switch (res >> 26) {
15594 case ALC880_HP_EVENT:
15595 alc663_g71v_hp_automute(codec);
15597 case ALC880_FRONT_EVENT:
15598 alc663_g71v_front_automute(codec);
15600 case ALC880_MIC_EVENT:
15601 alc662_eeepc_mic_automute(codec);
15606 static void alc663_g71v_inithook(struct hda_codec *codec)
15608 alc663_g71v_front_automute(codec);
15609 alc663_g71v_hp_automute(codec);
15610 alc662_eeepc_mic_automute(codec);
15613 static void alc663_g50v_unsol_event(struct hda_codec *codec,
15616 switch (res >> 26) {
15617 case ALC880_HP_EVENT:
15618 alc663_m51va_speaker_automute(codec);
15620 case ALC880_MIC_EVENT:
15621 alc662_eeepc_mic_automute(codec);
15626 static void alc663_g50v_inithook(struct hda_codec *codec)
15628 alc663_m51va_speaker_automute(codec);
15629 alc662_eeepc_mic_automute(codec);
15632 /* bind hp and internal speaker mute (with plug check) */
15633 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
15634 struct snd_ctl_elem_value *ucontrol)
15636 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
15637 long *valp = ucontrol->value.integer.value;
15640 change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
15642 valp[0] ? 0 : HDA_AMP_MUTE);
15643 change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
15645 valp[1] ? 0 : HDA_AMP_MUTE);
15647 alc262_hippo1_automute(codec);
15651 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
15652 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15654 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15655 .name = "Master Playback Switch",
15656 .info = snd_hda_mixer_amp_switch_info,
15657 .get = snd_hda_mixer_amp_switch_get,
15658 .put = alc662_ecs_master_sw_put,
15659 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15662 HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
15663 HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
15664 HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
15666 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15667 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15668 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15672 #ifdef CONFIG_SND_HDA_POWER_SAVE
15673 #define alc662_loopbacks alc880_loopbacks
15677 /* pcm configuration: identiacal with ALC880 */
15678 #define alc662_pcm_analog_playback alc880_pcm_analog_playback
15679 #define alc662_pcm_analog_capture alc880_pcm_analog_capture
15680 #define alc662_pcm_digital_playback alc880_pcm_digital_playback
15681 #define alc662_pcm_digital_capture alc880_pcm_digital_capture
15684 * configuration and preset
15686 static const char *alc662_models[ALC662_MODEL_LAST] = {
15687 [ALC662_3ST_2ch_DIG] = "3stack-dig",
15688 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig",
15689 [ALC662_3ST_6ch] = "3stack-6ch",
15690 [ALC662_5ST_DIG] = "6stack-dig",
15691 [ALC662_LENOVO_101E] = "lenovo-101e",
15692 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
15693 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
15694 [ALC662_ECS] = "ecs",
15695 [ALC663_ASUS_M51VA] = "m51va",
15696 [ALC663_ASUS_G71V] = "g71v",
15697 [ALC663_ASUS_H13] = "h13",
15698 [ALC663_ASUS_G50V] = "g50v",
15699 [ALC663_ASUS_MODE1] = "asus-mode1",
15700 [ALC662_ASUS_MODE2] = "asus-mode2",
15701 [ALC663_ASUS_MODE3] = "asus-mode3",
15702 [ALC663_ASUS_MODE4] = "asus-mode4",
15703 [ALC663_ASUS_MODE5] = "asus-mode5",
15704 [ALC663_ASUS_MODE6] = "asus-mode6",
15705 [ALC662_AUTO] = "auto",
15708 static struct snd_pci_quirk alc662_cfg_tbl[] = {
15709 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
15710 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
15711 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
15712 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
15713 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
15714 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
15715 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),
15716 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
15717 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
15718 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
15719 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),
15720 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
15721 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
15722 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
15723 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
15724 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
15725 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
15726 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
15727 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
15728 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
15729 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
15730 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
15731 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
15732 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
15733 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
15734 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
15735 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
15736 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
15737 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
15738 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
15739 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
15740 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
15741 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
15742 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
15743 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
15744 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
15745 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
15746 SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
15747 ALC662_3ST_6ch_DIG),
15748 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
15749 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
15750 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
15751 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
15752 ALC662_3ST_6ch_DIG),
15753 SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
15754 SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
15755 ALC662_3ST_6ch_DIG),
15756 SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
15757 SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
15758 SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
15762 static struct alc_config_preset alc662_presets[] = {
15763 [ALC662_3ST_2ch_DIG] = {
15764 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
15765 .init_verbs = { alc662_init_verbs },
15766 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15767 .dac_nids = alc662_dac_nids,
15768 .dig_out_nid = ALC662_DIGOUT_NID,
15769 .dig_in_nid = ALC662_DIGIN_NID,
15770 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15771 .channel_mode = alc662_3ST_2ch_modes,
15772 .input_mux = &alc662_capture_source,
15774 [ALC662_3ST_6ch_DIG] = {
15775 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15776 alc662_capture_mixer },
15777 .init_verbs = { alc662_init_verbs },
15778 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15779 .dac_nids = alc662_dac_nids,
15780 .dig_out_nid = ALC662_DIGOUT_NID,
15781 .dig_in_nid = ALC662_DIGIN_NID,
15782 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15783 .channel_mode = alc662_3ST_6ch_modes,
15785 .input_mux = &alc662_capture_source,
15787 [ALC662_3ST_6ch] = {
15788 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15789 alc662_capture_mixer },
15790 .init_verbs = { alc662_init_verbs },
15791 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15792 .dac_nids = alc662_dac_nids,
15793 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15794 .channel_mode = alc662_3ST_6ch_modes,
15796 .input_mux = &alc662_capture_source,
15798 [ALC662_5ST_DIG] = {
15799 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
15800 alc662_capture_mixer },
15801 .init_verbs = { alc662_init_verbs },
15802 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15803 .dac_nids = alc662_dac_nids,
15804 .dig_out_nid = ALC662_DIGOUT_NID,
15805 .dig_in_nid = ALC662_DIGIN_NID,
15806 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
15807 .channel_mode = alc662_5stack_modes,
15808 .input_mux = &alc662_capture_source,
15810 [ALC662_LENOVO_101E] = {
15811 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
15812 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
15813 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15814 .dac_nids = alc662_dac_nids,
15815 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15816 .channel_mode = alc662_3ST_2ch_modes,
15817 .input_mux = &alc662_lenovo_101e_capture_source,
15818 .unsol_event = alc662_lenovo_101e_unsol_event,
15819 .init_hook = alc662_lenovo_101e_all_automute,
15821 [ALC662_ASUS_EEEPC_P701] = {
15822 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
15823 .init_verbs = { alc662_init_verbs,
15824 alc662_eeepc_sue_init_verbs },
15825 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15826 .dac_nids = alc662_dac_nids,
15827 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15828 .channel_mode = alc662_3ST_2ch_modes,
15829 .input_mux = &alc662_eeepc_capture_source,
15830 .unsol_event = alc662_eeepc_unsol_event,
15831 .init_hook = alc662_eeepc_inithook,
15833 [ALC662_ASUS_EEEPC_EP20] = {
15834 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
15835 alc662_chmode_mixer },
15836 .init_verbs = { alc662_init_verbs,
15837 alc662_eeepc_ep20_sue_init_verbs },
15838 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15839 .dac_nids = alc662_dac_nids,
15840 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15841 .channel_mode = alc662_3ST_6ch_modes,
15842 .input_mux = &alc662_lenovo_101e_capture_source,
15843 .unsol_event = alc662_eeepc_ep20_unsol_event,
15844 .init_hook = alc662_eeepc_ep20_inithook,
15847 .mixers = { alc662_ecs_mixer, alc662_capture_mixer },
15848 .init_verbs = { alc662_init_verbs,
15849 alc662_ecs_init_verbs },
15850 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15851 .dac_nids = alc662_dac_nids,
15852 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15853 .channel_mode = alc662_3ST_2ch_modes,
15854 .input_mux = &alc662_eeepc_capture_source,
15855 .unsol_event = alc662_eeepc_unsol_event,
15856 .init_hook = alc662_eeepc_inithook,
15858 [ALC663_ASUS_M51VA] = {
15859 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15860 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15861 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15862 .dac_nids = alc662_dac_nids,
15863 .dig_out_nid = ALC662_DIGOUT_NID,
15864 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15865 .channel_mode = alc662_3ST_2ch_modes,
15866 .input_mux = &alc663_m51va_capture_source,
15867 .unsol_event = alc663_m51va_unsol_event,
15868 .init_hook = alc663_m51va_inithook,
15870 [ALC663_ASUS_G71V] = {
15871 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
15872 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
15873 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15874 .dac_nids = alc662_dac_nids,
15875 .dig_out_nid = ALC662_DIGOUT_NID,
15876 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15877 .channel_mode = alc662_3ST_2ch_modes,
15878 .input_mux = &alc662_eeepc_capture_source,
15879 .unsol_event = alc663_g71v_unsol_event,
15880 .init_hook = alc663_g71v_inithook,
15882 [ALC663_ASUS_H13] = {
15883 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15884 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15885 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15886 .dac_nids = alc662_dac_nids,
15887 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15888 .channel_mode = alc662_3ST_2ch_modes,
15889 .input_mux = &alc663_m51va_capture_source,
15890 .unsol_event = alc663_m51va_unsol_event,
15891 .init_hook = alc663_m51va_inithook,
15893 [ALC663_ASUS_G50V] = {
15894 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
15895 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
15896 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15897 .dac_nids = alc662_dac_nids,
15898 .dig_out_nid = ALC662_DIGOUT_NID,
15899 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15900 .channel_mode = alc662_3ST_6ch_modes,
15901 .input_mux = &alc663_capture_source,
15902 .unsol_event = alc663_g50v_unsol_event,
15903 .init_hook = alc663_g50v_inithook,
15905 [ALC663_ASUS_MODE1] = {
15906 .mixers = { alc663_m51va_mixer, alc662_auto_capture_mixer },
15907 .init_verbs = { alc662_init_verbs,
15908 alc663_21jd_amic_init_verbs },
15909 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15911 .dac_nids = alc662_dac_nids,
15912 .dig_out_nid = ALC662_DIGOUT_NID,
15913 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15914 .channel_mode = alc662_3ST_2ch_modes,
15915 .input_mux = &alc662_eeepc_capture_source,
15916 .unsol_event = alc663_mode1_unsol_event,
15917 .init_hook = alc663_mode1_inithook,
15919 [ALC662_ASUS_MODE2] = {
15920 .mixers = { alc662_1bjd_mixer, alc662_auto_capture_mixer },
15921 .init_verbs = { alc662_init_verbs,
15922 alc662_1bjd_amic_init_verbs },
15923 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15924 .dac_nids = alc662_dac_nids,
15925 .dig_out_nid = ALC662_DIGOUT_NID,
15926 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15927 .channel_mode = alc662_3ST_2ch_modes,
15928 .input_mux = &alc662_eeepc_capture_source,
15929 .unsol_event = alc662_mode2_unsol_event,
15930 .init_hook = alc662_mode2_inithook,
15932 [ALC663_ASUS_MODE3] = {
15933 .mixers = { alc663_two_hp_m1_mixer, alc662_auto_capture_mixer },
15934 .init_verbs = { alc662_init_verbs,
15935 alc663_two_hp_amic_m1_init_verbs },
15936 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15938 .dac_nids = alc662_dac_nids,
15939 .dig_out_nid = ALC662_DIGOUT_NID,
15940 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15941 .channel_mode = alc662_3ST_2ch_modes,
15942 .input_mux = &alc662_eeepc_capture_source,
15943 .unsol_event = alc663_mode3_unsol_event,
15944 .init_hook = alc663_mode3_inithook,
15946 [ALC663_ASUS_MODE4] = {
15947 .mixers = { alc663_asus_21jd_clfe_mixer,
15948 alc662_auto_capture_mixer},
15949 .init_verbs = { alc662_init_verbs,
15950 alc663_21jd_amic_init_verbs},
15951 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15953 .dac_nids = alc662_dac_nids,
15954 .dig_out_nid = ALC662_DIGOUT_NID,
15955 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15956 .channel_mode = alc662_3ST_2ch_modes,
15957 .input_mux = &alc662_eeepc_capture_source,
15958 .unsol_event = alc663_mode4_unsol_event,
15959 .init_hook = alc663_mode4_inithook,
15961 [ALC663_ASUS_MODE5] = {
15962 .mixers = { alc663_asus_15jd_clfe_mixer,
15963 alc662_auto_capture_mixer },
15964 .init_verbs = { alc662_init_verbs,
15965 alc663_15jd_amic_init_verbs },
15966 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15968 .dac_nids = alc662_dac_nids,
15969 .dig_out_nid = ALC662_DIGOUT_NID,
15970 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15971 .channel_mode = alc662_3ST_2ch_modes,
15972 .input_mux = &alc662_eeepc_capture_source,
15973 .unsol_event = alc663_mode5_unsol_event,
15974 .init_hook = alc663_mode5_inithook,
15976 [ALC663_ASUS_MODE6] = {
15977 .mixers = { alc663_two_hp_m2_mixer, alc662_auto_capture_mixer },
15978 .init_verbs = { alc662_init_verbs,
15979 alc663_two_hp_amic_m2_init_verbs },
15980 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15982 .dac_nids = alc662_dac_nids,
15983 .dig_out_nid = ALC662_DIGOUT_NID,
15984 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15985 .channel_mode = alc662_3ST_2ch_modes,
15986 .input_mux = &alc662_eeepc_capture_source,
15987 .unsol_event = alc663_mode6_unsol_event,
15988 .init_hook = alc663_mode6_inithook,
15994 * BIOS auto configuration
15997 /* add playback controls from the parsed DAC table */
15998 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
15999 const struct auto_pin_cfg *cfg)
16002 static const char *chname[4] = {
16003 "Front", "Surround", NULL /*CLFE*/, "Side"
16008 for (i = 0; i < cfg->line_outs; i++) {
16009 if (!spec->multiout.dac_nids[i])
16011 nid = alc880_idx_to_dac(i);
16014 err = add_control(spec, ALC_CTL_WIDGET_VOL,
16015 "Center Playback Volume",
16016 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16020 err = add_control(spec, ALC_CTL_WIDGET_VOL,
16021 "LFE Playback Volume",
16022 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16026 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16027 "Center Playback Switch",
16028 HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16032 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16033 "LFE Playback Switch",
16034 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16039 sprintf(name, "%s Playback Volume", chname[i]);
16040 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16041 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16045 sprintf(name, "%s Playback Switch", chname[i]);
16046 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16047 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16056 /* add playback controls for speaker and HP outputs */
16057 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16068 /* ALC663 has a mono output pin on 0x17 */
16069 sprintf(name, "%s Playback Switch", pfx);
16070 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16071 HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16075 if (alc880_is_fixed_pin(pin)) {
16076 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16077 /* printk("DAC nid=%x\n",nid); */
16078 /* specify the DAC as the extra output */
16079 if (!spec->multiout.hp_nid)
16080 spec->multiout.hp_nid = nid;
16082 spec->multiout.extra_out_nid[0] = nid;
16083 /* control HP volume/switch on the output mixer amp */
16084 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16085 sprintf(name, "%s Playback Volume", pfx);
16086 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16087 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16090 sprintf(name, "%s Playback Switch", pfx);
16091 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16092 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16095 } else if (alc880_is_multi_pin(pin)) {
16096 /* set manual connection */
16097 /* we have only a switch on HP-out PIN */
16098 sprintf(name, "%s Playback Switch", pfx);
16099 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16100 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16107 /* create playback/capture controls for input pins */
16108 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16109 const struct auto_pin_cfg *cfg)
16111 struct hda_input_mux *imux = &spec->private_imux;
16114 for (i = 0; i < AUTO_PIN_LAST; i++) {
16115 if (alc880_is_input_pin(cfg->input_pins[i])) {
16116 idx = alc880_input_pin_idx(cfg->input_pins[i]);
16117 err = new_analog_input(spec, cfg->input_pins[i],
16118 auto_pin_cfg_labels[i],
16122 imux->items[imux->num_items].label =
16123 auto_pin_cfg_labels[i];
16124 imux->items[imux->num_items].index =
16125 alc880_input_pin_idx(cfg->input_pins[i]);
16132 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16133 hda_nid_t nid, int pin_type,
16136 alc_set_pin_output(codec, nid, pin_type);
16137 /* need the manual connection? */
16138 if (alc880_is_multi_pin(nid)) {
16139 struct alc_spec *spec = codec->spec;
16140 int idx = alc880_multi_pin_idx(nid);
16141 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16142 AC_VERB_SET_CONNECT_SEL,
16143 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16147 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16149 struct alc_spec *spec = codec->spec;
16152 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16153 for (i = 0; i <= HDA_SIDE; i++) {
16154 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16155 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16157 alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16162 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16164 struct alc_spec *spec = codec->spec;
16167 pin = spec->autocfg.hp_pins[0];
16168 if (pin) /* connect to front */
16170 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16171 pin = spec->autocfg.speaker_pins[0];
16173 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16176 #define alc662_is_input_pin(nid) alc880_is_input_pin(nid)
16177 #define ALC662_PIN_CD_NID ALC880_PIN_CD_NID
16179 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16181 struct alc_spec *spec = codec->spec;
16184 for (i = 0; i < AUTO_PIN_LAST; i++) {
16185 hda_nid_t nid = spec->autocfg.input_pins[i];
16186 if (alc662_is_input_pin(nid)) {
16187 snd_hda_codec_write(codec, nid, 0,
16188 AC_VERB_SET_PIN_WIDGET_CONTROL,
16189 (i <= AUTO_PIN_FRONT_MIC ?
16190 PIN_VREF80 : PIN_IN));
16191 if (nid != ALC662_PIN_CD_NID)
16192 snd_hda_codec_write(codec, nid, 0,
16193 AC_VERB_SET_AMP_GAIN_MUTE,
16199 #define alc662_auto_init_input_src alc882_auto_init_input_src
16201 static int alc662_parse_auto_config(struct hda_codec *codec)
16203 struct alc_spec *spec = codec->spec;
16205 static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16207 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16211 if (!spec->autocfg.line_outs)
16212 return 0; /* can't find valid BIOS pin config */
16214 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16217 err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16220 err = alc662_auto_create_extra_out(spec,
16221 spec->autocfg.speaker_pins[0],
16225 err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16229 err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16233 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16235 if (spec->autocfg.dig_out_pin)
16236 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16238 if (spec->kctl_alloc)
16239 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
16241 spec->num_mux_defs = 1;
16242 spec->input_mux = &spec->private_imux;
16244 spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
16245 if (codec->vendor_id == 0x10ec0663)
16246 spec->init_verbs[spec->num_init_verbs++] =
16247 alc663_auto_init_verbs;
16249 err = alc_auto_add_mic_boost(codec);
16253 spec->mixers[spec->num_mixers] = alc662_capture_mixer;
16254 spec->num_mixers++;
16258 /* additional initialization for auto-configuration model */
16259 static void alc662_auto_init(struct hda_codec *codec)
16261 struct alc_spec *spec = codec->spec;
16262 alc662_auto_init_multi_out(codec);
16263 alc662_auto_init_hp_out(codec);
16264 alc662_auto_init_analog_input(codec);
16265 alc662_auto_init_input_src(codec);
16266 if (spec->unsol_event)
16267 alc_inithook(codec);
16270 static int patch_alc662(struct hda_codec *codec)
16272 struct alc_spec *spec;
16273 int err, board_config;
16275 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16279 codec->spec = spec;
16281 alc_fix_pll_init(codec, 0x20, 0x04, 15);
16283 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16286 if (board_config < 0) {
16287 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16288 "trying auto-probe from BIOS...\n");
16289 board_config = ALC662_AUTO;
16292 if (board_config == ALC662_AUTO) {
16293 /* automatic parse from the BIOS config */
16294 err = alc662_parse_auto_config(codec);
16300 "hda_codec: Cannot set up configuration "
16301 "from BIOS. Using base mode...\n");
16302 board_config = ALC662_3ST_2ch_DIG;
16306 if (board_config != ALC662_AUTO)
16307 setup_preset(spec, &alc662_presets[board_config]);
16309 if (codec->vendor_id == 0x10ec0663) {
16310 spec->stream_name_analog = "ALC663 Analog";
16311 spec->stream_name_digital = "ALC663 Digital";
16312 } else if (codec->vendor_id == 0x10ec0272) {
16313 spec->stream_name_analog = "ALC272 Analog";
16314 spec->stream_name_digital = "ALC272 Digital";
16316 spec->stream_name_analog = "ALC662 Analog";
16317 spec->stream_name_digital = "ALC662 Digital";
16320 spec->stream_analog_playback = &alc662_pcm_analog_playback;
16321 spec->stream_analog_capture = &alc662_pcm_analog_capture;
16323 spec->stream_digital_playback = &alc662_pcm_digital_playback;
16324 spec->stream_digital_capture = &alc662_pcm_digital_capture;
16326 spec->adc_nids = alc662_adc_nids;
16327 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16328 spec->capsrc_nids = alc662_capsrc_nids;
16330 spec->vmaster_nid = 0x02;
16332 codec->patch_ops = alc_patch_ops;
16333 if (board_config == ALC662_AUTO)
16334 spec->init_hook = alc662_auto_init;
16335 #ifdef CONFIG_SND_HDA_POWER_SAVE
16336 if (!spec->loopback.amplist)
16337 spec->loopback.amplist = alc662_loopbacks;
16346 struct hda_codec_preset snd_hda_preset_realtek[] = {
16347 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16348 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16349 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16350 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16351 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16352 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16353 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16354 .patch = patch_alc861 },
16355 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16356 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16357 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16358 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16359 .patch = patch_alc883 },
16360 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16361 .patch = patch_alc662 },
16362 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16363 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16364 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16365 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16366 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16367 .patch = patch_alc882 }, /* should be patch_alc883() in future */
16368 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16369 .patch = patch_alc882 }, /* should be patch_alc883() in future */
16370 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16371 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
16372 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16373 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
16374 .patch = patch_alc883 },
16375 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16376 {} /* terminator */