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 */
80 #ifdef CONFIG_SND_DEBUG
84 ALC260_MODEL_LAST /* last tag */
94 ALC262_HP_BPC_D7000_WL,
95 ALC262_HP_BPC_D7000_WF,
104 ALC262_MODEL_LAST /* last tag */
115 #ifdef CONFIG_SND_DEBUG
119 ALC268_MODEL_LAST /* last tag */
126 ALC269_MODEL_LAST /* last tag */
143 /* ALC861-VD models */
164 ALC662_ASUS_EEEPC_P701,
165 ALC662_ASUS_EEEPC_EP20,
197 ALC883_TARGA_2ch_DIG,
203 ALC883_LENOVO_101E_2ch,
204 ALC883_LENOVO_NB0763,
205 ALC888_LENOVO_MS7195_DIG,
211 ALC883_FUJITSU_PI2515,
212 ALC883_3ST_6ch_INTEL,
218 #define GPIO_MASK 0x03
221 /* codec parameterization */
222 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
223 unsigned int num_mixers;
225 const struct hda_verb *init_verbs[5]; /* initialization verbs
229 unsigned int num_init_verbs;
231 char *stream_name_analog; /* analog PCM stream */
232 struct hda_pcm_stream *stream_analog_playback;
233 struct hda_pcm_stream *stream_analog_capture;
234 struct hda_pcm_stream *stream_analog_alt_playback;
235 struct hda_pcm_stream *stream_analog_alt_capture;
237 char *stream_name_digital; /* digital PCM stream */
238 struct hda_pcm_stream *stream_digital_playback;
239 struct hda_pcm_stream *stream_digital_capture;
242 struct hda_multi_out multiout; /* playback set-up
243 * max_channels, dacs must be set
244 * dig_out_nid and hp_nid are optional
246 hda_nid_t alt_dac_nid;
249 unsigned int num_adc_nids;
251 hda_nid_t *capsrc_nids;
252 hda_nid_t dig_in_nid; /* digital-in NID; optional */
255 unsigned int num_mux_defs;
256 const struct hda_input_mux *input_mux;
257 unsigned int cur_mux[3];
260 const struct hda_channel_mode *channel_mode;
261 int num_channel_mode;
264 /* PCM information */
265 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
267 /* dynamic controls, init_verbs and input_mux */
268 struct auto_pin_cfg autocfg;
269 unsigned int num_kctl_alloc, num_kctl_used;
270 struct snd_kcontrol_new *kctl_alloc;
271 struct hda_input_mux private_imux;
272 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
275 void (*init_hook)(struct hda_codec *codec);
276 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
278 /* for pin sensing */
279 unsigned int sense_updated: 1;
280 unsigned int jack_present: 1;
281 unsigned int master_sw: 1;
283 /* for virtual master */
284 hda_nid_t vmaster_nid;
285 #ifdef CONFIG_SND_HDA_POWER_SAVE
286 struct hda_loopback_check loopback;
291 unsigned int pll_coef_idx, pll_coef_bit;
295 * configuration template - to be copied to the spec instance
297 struct alc_config_preset {
298 struct snd_kcontrol_new *mixers[5]; /* should be identical size
301 const struct hda_verb *init_verbs[5];
302 unsigned int num_dacs;
304 hda_nid_t dig_out_nid; /* optional */
305 hda_nid_t hp_nid; /* optional */
306 unsigned int num_adc_nids;
308 hda_nid_t *capsrc_nids;
309 hda_nid_t dig_in_nid;
310 unsigned int num_channel_mode;
311 const struct hda_channel_mode *channel_mode;
313 unsigned int num_mux_defs;
314 const struct hda_input_mux *input_mux;
315 void (*unsol_event)(struct hda_codec *, unsigned int);
316 void (*init_hook)(struct hda_codec *);
317 #ifdef CONFIG_SND_HDA_POWER_SAVE
318 struct hda_amp_list *loopbacks;
326 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
327 struct snd_ctl_elem_info *uinfo)
329 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
330 struct alc_spec *spec = codec->spec;
331 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
332 if (mux_idx >= spec->num_mux_defs)
334 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
337 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
338 struct snd_ctl_elem_value *ucontrol)
340 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
341 struct alc_spec *spec = codec->spec;
342 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
344 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
348 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
349 struct snd_ctl_elem_value *ucontrol)
351 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
352 struct alc_spec *spec = codec->spec;
353 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
354 unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
355 hda_nid_t nid = spec->capsrc_nids ?
356 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
357 return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
358 nid, &spec->cur_mux[adc_idx]);
363 * channel mode setting
365 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
366 struct snd_ctl_elem_info *uinfo)
368 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
369 struct alc_spec *spec = codec->spec;
370 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
371 spec->num_channel_mode);
374 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
375 struct snd_ctl_elem_value *ucontrol)
377 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
378 struct alc_spec *spec = codec->spec;
379 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
380 spec->num_channel_mode,
381 spec->multiout.max_channels);
384 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
385 struct snd_ctl_elem_value *ucontrol)
387 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
388 struct alc_spec *spec = codec->spec;
389 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
390 spec->num_channel_mode,
391 &spec->multiout.max_channels);
392 if (err >= 0 && spec->need_dac_fix)
393 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
398 * Control the mode of pin widget settings via the mixer. "pc" is used
399 * instead of "%" to avoid consequences of accidently treating the % as
400 * being part of a format specifier. Maximum allowed length of a value is
401 * 63 characters plus NULL terminator.
403 * Note: some retasking pin complexes seem to ignore requests for input
404 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
405 * are requested. Therefore order this list so that this behaviour will not
406 * cause problems when mixer clients move through the enum sequentially.
407 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
410 static char *alc_pin_mode_names[] = {
411 "Mic 50pc bias", "Mic 80pc bias",
412 "Line in", "Line out", "Headphone out",
414 static unsigned char alc_pin_mode_values[] = {
415 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
417 /* The control can present all 5 options, or it can limit the options based
418 * in the pin being assumed to be exclusively an input or an output pin. In
419 * addition, "input" pins may or may not process the mic bias option
420 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
421 * accept requests for bias as of chip versions up to March 2006) and/or
422 * wiring in the computer.
424 #define ALC_PIN_DIR_IN 0x00
425 #define ALC_PIN_DIR_OUT 0x01
426 #define ALC_PIN_DIR_INOUT 0x02
427 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03
428 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
430 /* Info about the pin modes supported by the different pin direction modes.
431 * For each direction the minimum and maximum values are given.
433 static signed char alc_pin_mode_dir_info[5][2] = {
434 { 0, 2 }, /* ALC_PIN_DIR_IN */
435 { 3, 4 }, /* ALC_PIN_DIR_OUT */
436 { 0, 4 }, /* ALC_PIN_DIR_INOUT */
437 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
438 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
440 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
441 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
442 #define alc_pin_mode_n_items(_dir) \
443 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
445 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
446 struct snd_ctl_elem_info *uinfo)
448 unsigned int item_num = uinfo->value.enumerated.item;
449 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
451 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
453 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
455 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
456 item_num = alc_pin_mode_min(dir);
457 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
461 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
462 struct snd_ctl_elem_value *ucontrol)
465 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
466 hda_nid_t nid = kcontrol->private_value & 0xffff;
467 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
468 long *valp = ucontrol->value.integer.value;
469 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
470 AC_VERB_GET_PIN_WIDGET_CONTROL,
473 /* Find enumerated value for current pinctl setting */
474 i = alc_pin_mode_min(dir);
475 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
477 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
481 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
482 struct snd_ctl_elem_value *ucontrol)
485 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
486 hda_nid_t nid = kcontrol->private_value & 0xffff;
487 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
488 long val = *ucontrol->value.integer.value;
489 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
490 AC_VERB_GET_PIN_WIDGET_CONTROL,
493 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
494 val = alc_pin_mode_min(dir);
496 change = pinctl != alc_pin_mode_values[val];
498 /* Set pin mode to that requested */
499 snd_hda_codec_write_cache(codec, nid, 0,
500 AC_VERB_SET_PIN_WIDGET_CONTROL,
501 alc_pin_mode_values[val]);
503 /* Also enable the retasking pin's input/output as required
504 * for the requested pin mode. Enum values of 2 or less are
507 * Dynamically switching the input/output buffers probably
508 * reduces noise slightly (particularly on input) so we'll
509 * do it. However, having both input and output buffers
510 * enabled simultaneously doesn't seem to be problematic if
511 * this turns out to be necessary in the future.
514 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
515 HDA_AMP_MUTE, HDA_AMP_MUTE);
516 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
519 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
520 HDA_AMP_MUTE, HDA_AMP_MUTE);
521 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
528 #define ALC_PIN_MODE(xname, nid, dir) \
529 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
530 .info = alc_pin_mode_info, \
531 .get = alc_pin_mode_get, \
532 .put = alc_pin_mode_put, \
533 .private_value = nid | (dir<<16) }
535 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
536 * together using a mask with more than one bit set. This control is
537 * currently used only by the ALC260 test model. At this stage they are not
538 * needed for any "production" models.
540 #ifdef CONFIG_SND_DEBUG
541 #define alc_gpio_data_info snd_ctl_boolean_mono_info
543 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
544 struct snd_ctl_elem_value *ucontrol)
546 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
547 hda_nid_t nid = kcontrol->private_value & 0xffff;
548 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
549 long *valp = ucontrol->value.integer.value;
550 unsigned int val = snd_hda_codec_read(codec, nid, 0,
551 AC_VERB_GET_GPIO_DATA, 0x00);
553 *valp = (val & mask) != 0;
556 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
557 struct snd_ctl_elem_value *ucontrol)
560 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
561 hda_nid_t nid = kcontrol->private_value & 0xffff;
562 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
563 long val = *ucontrol->value.integer.value;
564 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
565 AC_VERB_GET_GPIO_DATA,
568 /* Set/unset the masked GPIO bit(s) as needed */
569 change = (val == 0 ? 0 : mask) != (gpio_data & mask);
574 snd_hda_codec_write_cache(codec, nid, 0,
575 AC_VERB_SET_GPIO_DATA, gpio_data);
579 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
580 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
581 .info = alc_gpio_data_info, \
582 .get = alc_gpio_data_get, \
583 .put = alc_gpio_data_put, \
584 .private_value = nid | (mask<<16) }
585 #endif /* CONFIG_SND_DEBUG */
587 /* A switch control to allow the enabling of the digital IO pins on the
588 * ALC260. This is incredibly simplistic; the intention of this control is
589 * to provide something in the test model allowing digital outputs to be
590 * identified if present. If models are found which can utilise these
591 * outputs a more complete mixer control can be devised for those models if
594 #ifdef CONFIG_SND_DEBUG
595 #define alc_spdif_ctrl_info snd_ctl_boolean_mono_info
597 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
598 struct snd_ctl_elem_value *ucontrol)
600 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
601 hda_nid_t nid = kcontrol->private_value & 0xffff;
602 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
603 long *valp = ucontrol->value.integer.value;
604 unsigned int val = snd_hda_codec_read(codec, nid, 0,
605 AC_VERB_GET_DIGI_CONVERT_1, 0x00);
607 *valp = (val & mask) != 0;
610 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
611 struct snd_ctl_elem_value *ucontrol)
614 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
615 hda_nid_t nid = kcontrol->private_value & 0xffff;
616 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
617 long val = *ucontrol->value.integer.value;
618 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
619 AC_VERB_GET_DIGI_CONVERT_1,
622 /* Set/unset the masked control bit(s) as needed */
623 change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
628 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
633 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
634 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
635 .info = alc_spdif_ctrl_info, \
636 .get = alc_spdif_ctrl_get, \
637 .put = alc_spdif_ctrl_put, \
638 .private_value = nid | (mask<<16) }
639 #endif /* CONFIG_SND_DEBUG */
641 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
642 * Again, this is only used in the ALC26x test models to help identify when
643 * the EAPD line must be asserted for features to work.
645 #ifdef CONFIG_SND_DEBUG
646 #define alc_eapd_ctrl_info snd_ctl_boolean_mono_info
648 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
649 struct snd_ctl_elem_value *ucontrol)
651 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
652 hda_nid_t nid = kcontrol->private_value & 0xffff;
653 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
654 long *valp = ucontrol->value.integer.value;
655 unsigned int val = snd_hda_codec_read(codec, nid, 0,
656 AC_VERB_GET_EAPD_BTLENABLE, 0x00);
658 *valp = (val & mask) != 0;
662 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
663 struct snd_ctl_elem_value *ucontrol)
666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
667 hda_nid_t nid = kcontrol->private_value & 0xffff;
668 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
669 long val = *ucontrol->value.integer.value;
670 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
671 AC_VERB_GET_EAPD_BTLENABLE,
674 /* Set/unset the masked control bit(s) as needed */
675 change = (!val ? 0 : mask) != (ctrl_data & mask);
680 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
686 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
687 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
688 .info = alc_eapd_ctrl_info, \
689 .get = alc_eapd_ctrl_get, \
690 .put = alc_eapd_ctrl_put, \
691 .private_value = nid | (mask<<16) }
692 #endif /* CONFIG_SND_DEBUG */
695 * set up from the preset table
697 static void setup_preset(struct alc_spec *spec,
698 const struct alc_config_preset *preset)
702 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
703 spec->mixers[spec->num_mixers++] = preset->mixers[i];
704 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
706 spec->init_verbs[spec->num_init_verbs++] =
707 preset->init_verbs[i];
709 spec->channel_mode = preset->channel_mode;
710 spec->num_channel_mode = preset->num_channel_mode;
711 spec->need_dac_fix = preset->need_dac_fix;
713 spec->multiout.max_channels = spec->channel_mode[0].channels;
715 spec->multiout.num_dacs = preset->num_dacs;
716 spec->multiout.dac_nids = preset->dac_nids;
717 spec->multiout.dig_out_nid = preset->dig_out_nid;
718 spec->multiout.hp_nid = preset->hp_nid;
720 spec->num_mux_defs = preset->num_mux_defs;
721 if (!spec->num_mux_defs)
722 spec->num_mux_defs = 1;
723 spec->input_mux = preset->input_mux;
725 spec->num_adc_nids = preset->num_adc_nids;
726 spec->adc_nids = preset->adc_nids;
727 spec->capsrc_nids = preset->capsrc_nids;
728 spec->dig_in_nid = preset->dig_in_nid;
730 spec->unsol_event = preset->unsol_event;
731 spec->init_hook = preset->init_hook;
732 #ifdef CONFIG_SND_HDA_POWER_SAVE
733 spec->loopback.amplist = preset->loopbacks;
737 /* Enable GPIO mask and set output */
738 static struct hda_verb alc_gpio1_init_verbs[] = {
739 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
740 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
741 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
745 static struct hda_verb alc_gpio2_init_verbs[] = {
746 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
747 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
748 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
752 static struct hda_verb alc_gpio3_init_verbs[] = {
753 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
754 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
755 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
760 * Fix hardware PLL issue
761 * On some codecs, the analog PLL gating control must be off while
762 * the default value is 1.
764 static void alc_fix_pll(struct hda_codec *codec)
766 struct alc_spec *spec = codec->spec;
771 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
773 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
774 AC_VERB_GET_PROC_COEF, 0);
775 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
777 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
778 val & ~(1 << spec->pll_coef_bit));
781 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
782 unsigned int coef_idx, unsigned int coef_bit)
784 struct alc_spec *spec = codec->spec;
786 spec->pll_coef_idx = coef_idx;
787 spec->pll_coef_bit = coef_bit;
791 static void alc_sku_automute(struct hda_codec *codec)
793 struct alc_spec *spec = codec->spec;
794 unsigned int present;
795 unsigned int hp_nid = spec->autocfg.hp_pins[0];
796 unsigned int sp_nid = spec->autocfg.speaker_pins[0];
798 /* need to execute and sync at first */
799 snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
800 present = snd_hda_codec_read(codec, hp_nid, 0,
801 AC_VERB_GET_PIN_SENSE, 0);
802 spec->jack_present = (present & 0x80000000) != 0;
803 snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
804 spec->jack_present ? 0 : PIN_OUT);
807 /* unsolicited event for HP jack sensing */
808 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
810 if (codec->vendor_id == 0x10ec0880)
814 if (res != ALC880_HP_EVENT)
817 alc_sku_automute(codec);
820 /* additional initialization for ALC888 variants */
821 static void alc888_coef_init(struct hda_codec *codec)
825 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
826 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
827 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
828 if ((tmp & 0xf0) == 2)
830 snd_hda_codec_read(codec, 0x20, 0,
831 AC_VERB_SET_PROC_COEF, 0x830);
834 snd_hda_codec_read(codec, 0x20, 0,
835 AC_VERB_SET_PROC_COEF, 0x3030);
838 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
839 * 31 ~ 16 : Manufacture ID
841 * 7 ~ 0 : Assembly ID
842 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
844 static void alc_subsystem_id(struct hda_codec *codec,
845 unsigned int porta, unsigned int porte,
848 unsigned int ass, tmp, i;
850 struct alc_spec *spec = codec->spec;
852 ass = codec->subsystem_id & 0xffff;
853 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
857 * 31~30 : port conetcivity
860 * 19~16 : Check sum (15:1)
865 if (codec->vendor_id == 0x10ec0260)
867 ass = snd_hda_codec_read(codec, nid, 0,
868 AC_VERB_GET_CONFIG_DEFAULT, 0);
869 if (!(ass & 1) && !(ass & 0x100000))
871 if ((ass >> 30) != 1) /* no physical connection */
876 for (i = 1; i < 16; i++) {
880 if (((ass >> 16) & 0xf) != tmp)
886 * 2 : 0 --> Desktop, 1 --> Laptop
887 * 3~5 : External Amplifier control
890 tmp = (ass & 0x38) >> 3; /* external Amp control */
893 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
896 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
899 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
901 case 5: /* set EAPD output high */
902 switch (codec->vendor_id) {
904 snd_hda_codec_write(codec, 0x0f, 0,
905 AC_VERB_SET_EAPD_BTLENABLE, 2);
906 snd_hda_codec_write(codec, 0x10, 0,
907 AC_VERB_SET_EAPD_BTLENABLE, 2);
918 snd_hda_codec_write(codec, 0x14, 0,
919 AC_VERB_SET_EAPD_BTLENABLE, 2);
920 snd_hda_codec_write(codec, 0x15, 0,
921 AC_VERB_SET_EAPD_BTLENABLE, 2);
924 switch (codec->vendor_id) {
926 snd_hda_codec_write(codec, 0x1a, 0,
927 AC_VERB_SET_COEF_INDEX, 7);
928 tmp = snd_hda_codec_read(codec, 0x1a, 0,
929 AC_VERB_GET_PROC_COEF, 0);
930 snd_hda_codec_write(codec, 0x1a, 0,
931 AC_VERB_SET_COEF_INDEX, 7);
932 snd_hda_codec_write(codec, 0x1a, 0,
933 AC_VERB_SET_PROC_COEF,
942 snd_hda_codec_write(codec, 0x20, 0,
943 AC_VERB_SET_COEF_INDEX, 7);
944 tmp = snd_hda_codec_read(codec, 0x20, 0,
945 AC_VERB_GET_PROC_COEF, 0);
946 snd_hda_codec_write(codec, 0x20, 0,
947 AC_VERB_SET_COEF_INDEX, 7);
948 snd_hda_codec_write(codec, 0x20, 0,
949 AC_VERB_SET_PROC_COEF,
953 alc888_coef_init(codec);
957 snd_hda_codec_write(codec, 0x20, 0,
958 AC_VERB_SET_COEF_INDEX, 7);
959 tmp = snd_hda_codec_read(codec, 0x20, 0,
960 AC_VERB_GET_PROC_COEF, 0);
961 snd_hda_codec_write(codec, 0x20, 0,
962 AC_VERB_SET_COEF_INDEX, 7);
963 snd_hda_codec_write(codec, 0x20, 0,
964 AC_VERB_SET_PROC_COEF,
972 /* is laptop or Desktop and enable the function "Mute internal speaker
973 * when the external headphone out jack is plugged"
978 * 10~8 : Jack location
979 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
981 * 15 : 1 --> enable the function "Mute internal speaker
982 * when the external headphone out jack is plugged"
984 if (!spec->autocfg.speaker_pins[0]) {
985 if (spec->autocfg.line_out_pins[0])
986 spec->autocfg.speaker_pins[0] =
987 spec->autocfg.line_out_pins[0];
992 if (!spec->autocfg.hp_pins[0]) {
993 tmp = (ass >> 11) & 0x3; /* HP to chassis */
995 spec->autocfg.hp_pins[0] = porta;
997 spec->autocfg.hp_pins[0] = porte;
999 spec->autocfg.hp_pins[0] = portd;
1004 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1005 AC_VERB_SET_UNSOLICITED_ENABLE,
1006 AC_USRSP_EN | ALC880_HP_EVENT);
1007 spec->unsol_event = alc_sku_unsol_event;
1011 * Fix-up pin default configurations
1019 static void alc_fix_pincfg(struct hda_codec *codec,
1020 const struct snd_pci_quirk *quirk,
1021 const struct alc_pincfg **pinfix)
1023 const struct alc_pincfg *cfg;
1025 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1029 cfg = pinfix[quirk->value];
1030 for (; cfg->nid; cfg++) {
1033 for (i = 0; i < 4; i++) {
1034 snd_hda_codec_write(codec, cfg->nid, 0,
1035 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1043 * ALC880 3-stack model
1045 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1046 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1047 * F-Mic = 0x1b, HP = 0x19
1050 static hda_nid_t alc880_dac_nids[4] = {
1051 /* front, rear, clfe, rear_surr */
1052 0x02, 0x05, 0x04, 0x03
1055 static hda_nid_t alc880_adc_nids[3] = {
1060 /* The datasheet says the node 0x07 is connected from inputs,
1061 * but it shows zero connection in the real implementation on some devices.
1062 * Note: this is a 915GAV bug, fixed on 915GLV
1064 static hda_nid_t alc880_adc_nids_alt[2] = {
1069 #define ALC880_DIGOUT_NID 0x06
1070 #define ALC880_DIGIN_NID 0x0a
1072 static struct hda_input_mux alc880_capture_source = {
1076 { "Front Mic", 0x3 },
1082 /* channel source setting (2/6 channel selection for 3-stack) */
1084 static struct hda_verb alc880_threestack_ch2_init[] = {
1085 /* set line-in to input, mute it */
1086 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1087 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1088 /* set mic-in to input vref 80%, mute it */
1089 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1090 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1095 static struct hda_verb alc880_threestack_ch6_init[] = {
1096 /* set line-in to output, unmute it */
1097 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1098 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1099 /* set mic-in to output, unmute it */
1100 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1101 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1105 static struct hda_channel_mode alc880_threestack_modes[2] = {
1106 { 2, alc880_threestack_ch2_init },
1107 { 6, alc880_threestack_ch6_init },
1110 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1111 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1112 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1113 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1114 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1115 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1116 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1117 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1118 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1119 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1120 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1121 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1122 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1123 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1124 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1125 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1126 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1127 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1128 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1129 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1131 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1132 .name = "Channel Mode",
1133 .info = alc_ch_mode_info,
1134 .get = alc_ch_mode_get,
1135 .put = alc_ch_mode_put,
1140 /* capture mixer elements */
1141 static struct snd_kcontrol_new alc880_capture_mixer[] = {
1142 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
1143 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
1144 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
1145 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
1146 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
1147 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
1149 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1150 /* The multiple "Capture Source" controls confuse alsamixer
1151 * So call somewhat different..
1153 /* .name = "Capture Source", */
1154 .name = "Input Source",
1156 .info = alc_mux_enum_info,
1157 .get = alc_mux_enum_get,
1158 .put = alc_mux_enum_put,
1163 /* capture mixer elements (in case NID 0x07 not available) */
1164 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
1165 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1166 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1167 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
1168 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
1170 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1171 /* The multiple "Capture Source" controls confuse alsamixer
1172 * So call somewhat different..
1174 /* .name = "Capture Source", */
1175 .name = "Input Source",
1177 .info = alc_mux_enum_info,
1178 .get = alc_mux_enum_get,
1179 .put = alc_mux_enum_put,
1187 * ALC880 5-stack model
1189 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1191 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1192 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1195 /* additional mixers to alc880_three_stack_mixer */
1196 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1197 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1198 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1202 /* channel source setting (6/8 channel selection for 5-stack) */
1204 static struct hda_verb alc880_fivestack_ch6_init[] = {
1205 /* set line-in to input, mute it */
1206 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1207 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1212 static struct hda_verb alc880_fivestack_ch8_init[] = {
1213 /* set line-in to output, unmute it */
1214 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1215 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1219 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1220 { 6, alc880_fivestack_ch6_init },
1221 { 8, alc880_fivestack_ch8_init },
1226 * ALC880 6-stack model
1228 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1229 * Side = 0x05 (0x0f)
1230 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1231 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1234 static hda_nid_t alc880_6st_dac_nids[4] = {
1235 /* front, rear, clfe, rear_surr */
1236 0x02, 0x03, 0x04, 0x05
1239 static struct hda_input_mux alc880_6stack_capture_source = {
1243 { "Front Mic", 0x1 },
1249 /* fixed 8-channels */
1250 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1254 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1255 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1256 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1257 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1258 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1259 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1260 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1261 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1262 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1263 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1264 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1265 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1266 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1267 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1268 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1269 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1270 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1271 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1272 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1273 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1274 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1276 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1277 .name = "Channel Mode",
1278 .info = alc_ch_mode_info,
1279 .get = alc_ch_mode_get,
1280 .put = alc_ch_mode_put,
1289 * W810 has rear IO for:
1292 * Center/LFE (DAC 04)
1295 * The system also has a pair of internal speakers, and a headphone jack.
1296 * These are both connected to Line2 on the codec, hence to DAC 02.
1298 * There is a variable resistor to control the speaker or headphone
1299 * volume. This is a hardware-only device without a software API.
1301 * Plugging headphones in will disable the internal speakers. This is
1302 * implemented in hardware, not via the driver using jack sense. In
1303 * a similar fashion, plugging into the rear socket marked "front" will
1304 * disable both the speakers and headphones.
1306 * For input, there's a microphone jack, and an "audio in" jack.
1307 * These may not do anything useful with this driver yet, because I
1308 * haven't setup any initialization verbs for these yet...
1311 static hda_nid_t alc880_w810_dac_nids[3] = {
1312 /* front, rear/surround, clfe */
1316 /* fixed 6 channels */
1317 static struct hda_channel_mode alc880_w810_modes[1] = {
1321 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1322 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1323 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1324 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1325 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1326 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1327 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1328 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1329 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1330 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1331 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1339 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1340 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1344 static hda_nid_t alc880_z71v_dac_nids[1] = {
1347 #define ALC880_Z71V_HP_DAC 0x03
1349 /* fixed 2 channels */
1350 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1354 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1355 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1356 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1357 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1358 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1359 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1360 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1361 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1362 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1368 * ALC880 F1734 model
1370 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1371 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1374 static hda_nid_t alc880_f1734_dac_nids[1] = {
1377 #define ALC880_F1734_HP_DAC 0x02
1379 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1380 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1381 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1382 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1383 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1384 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1385 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1386 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1387 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1391 static struct hda_input_mux alc880_f1734_capture_source = {
1403 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1404 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1405 * Mic = 0x18, Line = 0x1a
1408 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */
1409 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */
1411 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1412 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1413 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1414 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1415 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1416 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1417 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1418 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1419 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1420 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1421 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1422 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1423 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1424 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1425 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1427 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1428 .name = "Channel Mode",
1429 .info = alc_ch_mode_info,
1430 .get = alc_ch_mode_get,
1431 .put = alc_ch_mode_put,
1437 * ALC880 ASUS W1V model
1439 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1440 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1441 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1444 /* additional mixers to alc880_asus_mixer */
1445 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1446 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1447 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1451 /* additional mixers to alc880_asus_mixer */
1452 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1453 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1454 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1459 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1460 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1461 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1462 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1463 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1464 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1465 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1466 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1467 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1468 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1470 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1471 /* The multiple "Capture Source" controls confuse alsamixer
1472 * So call somewhat different..
1474 /* .name = "Capture Source", */
1475 .name = "Input Source",
1477 .info = alc_mux_enum_info,
1478 .get = alc_mux_enum_get,
1479 .put = alc_mux_enum_put,
1485 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1486 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1487 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1488 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1489 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1490 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1491 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1492 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1493 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1494 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1495 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1496 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1497 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1498 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1499 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1500 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1501 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1502 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1503 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1505 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1506 .name = "Channel Mode",
1507 .info = alc_ch_mode_info,
1508 .get = alc_ch_mode_get,
1509 .put = alc_ch_mode_put,
1514 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1515 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1516 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1517 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1518 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1519 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1520 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1521 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1522 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1523 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1524 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1528 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1529 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1530 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1531 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1532 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1533 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1534 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1539 * virtual master controls
1543 * slave controls for virtual master
1545 static const char *alc_slave_vols[] = {
1546 "Front Playback Volume",
1547 "Surround Playback Volume",
1548 "Center Playback Volume",
1549 "LFE Playback Volume",
1550 "Side Playback Volume",
1551 "Headphone Playback Volume",
1552 "Speaker Playback Volume",
1553 "Mono Playback Volume",
1554 "Line-Out Playback Volume",
1558 static const char *alc_slave_sws[] = {
1559 "Front Playback Switch",
1560 "Surround Playback Switch",
1561 "Center Playback Switch",
1562 "LFE Playback Switch",
1563 "Side Playback Switch",
1564 "Headphone Playback Switch",
1565 "Speaker Playback Switch",
1566 "Mono Playback Switch",
1567 "IEC958 Playback Switch",
1572 * build control elements
1574 static int alc_build_controls(struct hda_codec *codec)
1576 struct alc_spec *spec = codec->spec;
1580 for (i = 0; i < spec->num_mixers; i++) {
1581 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1586 if (spec->multiout.dig_out_nid) {
1587 err = snd_hda_create_spdif_out_ctls(codec,
1588 spec->multiout.dig_out_nid);
1591 err = snd_hda_create_spdif_share_sw(codec,
1595 spec->multiout.share_spdif = 1;
1597 if (spec->dig_in_nid) {
1598 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1603 /* if we have no master control, let's create it */
1604 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1605 unsigned int vmaster_tlv[4];
1606 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1607 HDA_OUTPUT, vmaster_tlv);
1608 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1609 vmaster_tlv, alc_slave_vols);
1613 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1614 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1615 NULL, alc_slave_sws);
1625 * initialize the codec volumes, etc
1629 * generic initialization of ADC, input mixers and output mixers
1631 static struct hda_verb alc880_volume_init_verbs[] = {
1633 * Unmute ADC0-2 and set the default input to mic-in
1635 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1636 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1637 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1638 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1639 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1640 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1642 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1644 * Note: PASD motherboards uses the Line In 2 as the input for front
1647 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1648 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1649 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1650 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1651 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1652 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1653 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1654 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1657 * Set up output mixers (0x0c - 0x0f)
1659 /* set vol=0 to output mixers */
1660 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1661 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1662 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1663 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1664 /* set up input amps for analog loopback */
1665 /* Amp Indices: DAC = 0, mixer = 1 */
1666 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1667 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1668 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1669 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1670 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1671 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1672 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1673 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1679 * 3-stack pin configuration:
1680 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1682 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1684 * preset connection lists of input pins
1685 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1687 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1688 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1689 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1692 * Set pin mode and muting
1694 /* set front pin widgets 0x14 for output */
1695 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1696 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1697 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1698 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1699 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1700 /* Mic2 (as headphone out) for HP output */
1701 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1702 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1703 /* Line In pin widget for input */
1704 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1705 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1706 /* Line2 (as front mic) pin widget for input and vref at 80% */
1707 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1708 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1709 /* CD pin widget for input */
1710 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1716 * 5-stack pin configuration:
1717 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1718 * line-in/side = 0x1a, f-mic = 0x1b
1720 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1722 * preset connection lists of input pins
1723 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1725 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1726 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1729 * Set pin mode and muting
1731 /* set pin widgets 0x14-0x17 for output */
1732 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1733 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1734 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1735 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1736 /* unmute pins for output (no gain on this amp) */
1737 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1738 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1739 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1740 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1742 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1743 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1744 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1745 /* Mic2 (as headphone out) for HP output */
1746 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1747 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1748 /* Line In pin widget for input */
1749 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1750 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1751 /* Line2 (as front mic) pin widget for input and vref at 80% */
1752 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1753 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1754 /* CD pin widget for input */
1755 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1761 * W810 pin configuration:
1762 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1764 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1765 /* hphone/speaker input selector: front DAC */
1766 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1768 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1769 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1770 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1771 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1772 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1773 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1775 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1776 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1782 * Z71V pin configuration:
1783 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1785 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1786 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1787 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1788 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1789 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1791 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1792 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1793 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1794 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1800 * 6-stack pin configuration:
1801 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1802 * f-mic = 0x19, line = 0x1a, HP = 0x1b
1804 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1805 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1807 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1808 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1809 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1810 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1811 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1812 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1813 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1814 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1816 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1817 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1818 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1819 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1820 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1821 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1822 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1823 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1824 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1830 * Uniwill pin configuration:
1831 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1834 static struct hda_verb alc880_uniwill_init_verbs[] = {
1835 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1837 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1838 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1839 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1840 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1841 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1842 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1843 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1844 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1845 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1846 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1847 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1848 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1849 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1850 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1852 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1853 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1854 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1855 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1856 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1857 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1858 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1859 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1860 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1862 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1863 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1870 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1872 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1873 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1875 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1876 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1877 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1878 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1879 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1880 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1881 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1882 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1883 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1884 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1885 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1886 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1888 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1889 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1890 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1891 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1892 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1893 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1895 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1896 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1901 static struct hda_verb alc880_beep_init_verbs[] = {
1902 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1906 /* toggle speaker-output according to the hp-jack state */
1907 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
1909 unsigned int present;
1912 present = snd_hda_codec_read(codec, 0x14, 0,
1913 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1914 bits = present ? HDA_AMP_MUTE : 0;
1915 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1916 HDA_AMP_MUTE, bits);
1917 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
1918 HDA_AMP_MUTE, bits);
1921 /* auto-toggle front mic */
1922 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
1924 unsigned int present;
1927 present = snd_hda_codec_read(codec, 0x18, 0,
1928 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1929 bits = present ? HDA_AMP_MUTE : 0;
1930 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
1933 static void alc880_uniwill_automute(struct hda_codec *codec)
1935 alc880_uniwill_hp_automute(codec);
1936 alc880_uniwill_mic_automute(codec);
1939 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
1942 /* Looks like the unsol event is incompatible with the standard
1943 * definition. 4bit tag is placed at 28 bit!
1945 switch (res >> 28) {
1946 case ALC880_HP_EVENT:
1947 alc880_uniwill_hp_automute(codec);
1949 case ALC880_MIC_EVENT:
1950 alc880_uniwill_mic_automute(codec);
1955 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
1957 unsigned int present;
1960 present = snd_hda_codec_read(codec, 0x14, 0,
1961 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1962 bits = present ? HDA_AMP_MUTE : 0;
1963 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
1966 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
1968 unsigned int present;
1970 present = snd_hda_codec_read(codec, 0x21, 0,
1971 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
1972 present &= HDA_AMP_VOLMASK;
1973 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
1974 HDA_AMP_VOLMASK, present);
1975 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
1976 HDA_AMP_VOLMASK, present);
1979 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
1982 /* Looks like the unsol event is incompatible with the standard
1983 * definition. 4bit tag is placed at 28 bit!
1985 if ((res >> 28) == ALC880_HP_EVENT)
1986 alc880_uniwill_p53_hp_automute(codec);
1987 if ((res >> 28) == ALC880_DCVOL_EVENT)
1988 alc880_uniwill_p53_dcvol_automute(codec);
1992 * F1734 pin configuration:
1993 * HP = 0x14, speaker-out = 0x15, mic = 0x18
1995 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
1996 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
1997 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1998 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1999 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2000 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2002 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2003 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2004 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2005 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2007 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2008 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2009 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2010 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2011 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2012 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2013 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2014 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2015 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2017 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2018 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2024 * ASUS pin configuration:
2025 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2027 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2028 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2029 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2030 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2031 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2033 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2034 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2035 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2036 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2037 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2038 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2039 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2040 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2042 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2043 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2044 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2045 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2046 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2047 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2048 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2049 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2050 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2055 /* Enable GPIO mask and set output */
2056 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2057 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2059 /* Clevo m520g init */
2060 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2061 /* headphone output */
2062 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2064 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2065 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2067 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2068 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2070 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2071 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2072 /* Mic1 (rear panel) */
2073 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2074 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2075 /* Mic2 (front panel) */
2076 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2077 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2079 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2080 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2081 /* change to EAPD mode */
2082 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2083 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2088 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2089 /* change to EAPD mode */
2090 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2091 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2093 /* Headphone output */
2094 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2096 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2097 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2099 /* Line In pin widget for input */
2100 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2101 /* CD pin widget for input */
2102 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2103 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2104 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2106 /* change to EAPD mode */
2107 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2108 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
2114 * LG m1 express dual
2117 * Rear Line-In/Out (blue): 0x14
2118 * Build-in Mic-In: 0x15
2120 * HP-Out (green): 0x1b
2121 * Mic-In/Out (red): 0x19
2125 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2126 static hda_nid_t alc880_lg_dac_nids[3] = {
2130 /* seems analog CD is not working */
2131 static struct hda_input_mux alc880_lg_capture_source = {
2136 { "Internal Mic", 0x6 },
2140 /* 2,4,6 channel modes */
2141 static struct hda_verb alc880_lg_ch2_init[] = {
2142 /* set line-in and mic-in to input */
2143 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2144 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2148 static struct hda_verb alc880_lg_ch4_init[] = {
2149 /* set line-in to out and mic-in to input */
2150 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2151 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2155 static struct hda_verb alc880_lg_ch6_init[] = {
2156 /* set line-in and mic-in to output */
2157 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2158 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2162 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2163 { 2, alc880_lg_ch2_init },
2164 { 4, alc880_lg_ch4_init },
2165 { 6, alc880_lg_ch6_init },
2168 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2169 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2170 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2171 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2172 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2173 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2174 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2175 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2176 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2177 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2178 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2179 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2180 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2181 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2182 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2184 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2185 .name = "Channel Mode",
2186 .info = alc_ch_mode_info,
2187 .get = alc_ch_mode_get,
2188 .put = alc_ch_mode_put,
2193 static struct hda_verb alc880_lg_init_verbs[] = {
2194 /* set capture source to mic-in */
2195 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2196 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2197 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2198 /* mute all amp mixer inputs */
2199 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2200 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2201 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2202 /* line-in to input */
2203 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2204 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2206 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2207 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2209 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2210 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2211 /* mic-in to input */
2212 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2213 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2214 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2216 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2217 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2218 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2220 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2224 /* toggle speaker-output according to the hp-jack state */
2225 static void alc880_lg_automute(struct hda_codec *codec)
2227 unsigned int present;
2230 present = snd_hda_codec_read(codec, 0x1b, 0,
2231 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2232 bits = present ? HDA_AMP_MUTE : 0;
2233 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2234 HDA_AMP_MUTE, bits);
2237 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2239 /* Looks like the unsol event is incompatible with the standard
2240 * definition. 4bit tag is placed at 28 bit!
2242 if ((res >> 28) == 0x01)
2243 alc880_lg_automute(codec);
2252 * Built-in Mic-In: 0x19
2258 static struct hda_input_mux alc880_lg_lw_capture_source = {
2262 { "Internal Mic", 0x1 },
2267 #define alc880_lg_lw_modes alc880_threestack_modes
2269 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2270 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2271 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2272 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2273 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2274 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2275 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2276 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2277 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2278 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2279 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2280 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2281 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2282 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2283 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2285 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2286 .name = "Channel Mode",
2287 .info = alc_ch_mode_info,
2288 .get = alc_ch_mode_get,
2289 .put = alc_ch_mode_put,
2294 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2295 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2296 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2297 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2299 /* set capture source to mic-in */
2300 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2301 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2302 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2303 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2305 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2306 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2308 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2309 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2310 /* mic-in to input */
2311 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2312 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2314 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2315 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2317 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2321 /* toggle speaker-output according to the hp-jack state */
2322 static void alc880_lg_lw_automute(struct hda_codec *codec)
2324 unsigned int present;
2327 present = snd_hda_codec_read(codec, 0x1b, 0,
2328 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2329 bits = present ? HDA_AMP_MUTE : 0;
2330 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2331 HDA_AMP_MUTE, bits);
2334 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2336 /* Looks like the unsol event is incompatible with the standard
2337 * definition. 4bit tag is placed at 28 bit!
2339 if ((res >> 28) == 0x01)
2340 alc880_lg_lw_automute(codec);
2343 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2344 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2345 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2346 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2347 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2348 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2349 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2353 static struct hda_input_mux alc880_medion_rim_capture_source = {
2357 { "Internal Mic", 0x1 },
2361 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2362 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2364 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2365 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2367 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2368 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2369 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2370 /* Mic2 (as headphone out) for HP output */
2371 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2372 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2373 /* Internal Speaker */
2374 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2375 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2377 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2378 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2380 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2384 /* toggle speaker-output according to the hp-jack state */
2385 static void alc880_medion_rim_automute(struct hda_codec *codec)
2387 unsigned int present;
2390 present = snd_hda_codec_read(codec, 0x14, 0,
2391 AC_VERB_GET_PIN_SENSE, 0)
2392 & AC_PINSENSE_PRESENCE;
2393 bits = present ? HDA_AMP_MUTE : 0;
2394 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2395 HDA_AMP_MUTE, bits);
2397 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2399 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2402 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2405 /* Looks like the unsol event is incompatible with the standard
2406 * definition. 4bit tag is placed at 28 bit!
2408 if ((res >> 28) == ALC880_HP_EVENT)
2409 alc880_medion_rim_automute(codec);
2412 #ifdef CONFIG_SND_HDA_POWER_SAVE
2413 static struct hda_amp_list alc880_loopbacks[] = {
2414 { 0x0b, HDA_INPUT, 0 },
2415 { 0x0b, HDA_INPUT, 1 },
2416 { 0x0b, HDA_INPUT, 2 },
2417 { 0x0b, HDA_INPUT, 3 },
2418 { 0x0b, HDA_INPUT, 4 },
2422 static struct hda_amp_list alc880_lg_loopbacks[] = {
2423 { 0x0b, HDA_INPUT, 1 },
2424 { 0x0b, HDA_INPUT, 6 },
2425 { 0x0b, HDA_INPUT, 7 },
2434 static int alc_init(struct hda_codec *codec)
2436 struct alc_spec *spec = codec->spec;
2441 for (i = 0; i < spec->num_init_verbs; i++)
2442 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2444 if (spec->init_hook)
2445 spec->init_hook(codec);
2450 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2452 struct alc_spec *spec = codec->spec;
2454 if (spec->unsol_event)
2455 spec->unsol_event(codec, res);
2458 #ifdef CONFIG_SND_HDA_POWER_SAVE
2459 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2461 struct alc_spec *spec = codec->spec;
2462 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2467 * Analog playback callbacks
2469 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2470 struct hda_codec *codec,
2471 struct snd_pcm_substream *substream)
2473 struct alc_spec *spec = codec->spec;
2474 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2478 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2479 struct hda_codec *codec,
2480 unsigned int stream_tag,
2481 unsigned int format,
2482 struct snd_pcm_substream *substream)
2484 struct alc_spec *spec = codec->spec;
2485 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2486 stream_tag, format, substream);
2489 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2490 struct hda_codec *codec,
2491 struct snd_pcm_substream *substream)
2493 struct alc_spec *spec = codec->spec;
2494 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2500 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2501 struct hda_codec *codec,
2502 struct snd_pcm_substream *substream)
2504 struct alc_spec *spec = codec->spec;
2505 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2508 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2509 struct hda_codec *codec,
2510 unsigned int stream_tag,
2511 unsigned int format,
2512 struct snd_pcm_substream *substream)
2514 struct alc_spec *spec = codec->spec;
2515 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2516 stream_tag, format, substream);
2519 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2520 struct hda_codec *codec,
2521 struct snd_pcm_substream *substream)
2523 struct alc_spec *spec = codec->spec;
2524 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2530 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2531 struct hda_codec *codec,
2532 unsigned int stream_tag,
2533 unsigned int format,
2534 struct snd_pcm_substream *substream)
2536 struct alc_spec *spec = codec->spec;
2538 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2539 stream_tag, 0, format);
2543 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2544 struct hda_codec *codec,
2545 struct snd_pcm_substream *substream)
2547 struct alc_spec *spec = codec->spec;
2549 snd_hda_codec_cleanup_stream(codec,
2550 spec->adc_nids[substream->number + 1]);
2557 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2561 /* NID is set in alc_build_pcms */
2563 .open = alc880_playback_pcm_open,
2564 .prepare = alc880_playback_pcm_prepare,
2565 .cleanup = alc880_playback_pcm_cleanup
2569 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2573 /* NID is set in alc_build_pcms */
2576 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
2580 /* NID is set in alc_build_pcms */
2583 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
2584 .substreams = 2, /* can be overridden */
2587 /* NID is set in alc_build_pcms */
2589 .prepare = alc880_alt_capture_pcm_prepare,
2590 .cleanup = alc880_alt_capture_pcm_cleanup
2594 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2598 /* NID is set in alc_build_pcms */
2600 .open = alc880_dig_playback_pcm_open,
2601 .close = alc880_dig_playback_pcm_close,
2602 .prepare = alc880_dig_playback_pcm_prepare
2606 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2610 /* NID is set in alc_build_pcms */
2613 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2614 static struct hda_pcm_stream alc_pcm_null_stream = {
2620 static int alc_build_pcms(struct hda_codec *codec)
2622 struct alc_spec *spec = codec->spec;
2623 struct hda_pcm *info = spec->pcm_rec;
2626 codec->num_pcms = 1;
2627 codec->pcm_info = info;
2629 info->name = spec->stream_name_analog;
2630 if (spec->stream_analog_playback) {
2631 snd_assert(spec->multiout.dac_nids, return -EINVAL);
2632 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2633 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2635 if (spec->stream_analog_capture) {
2636 snd_assert(spec->adc_nids, return -EINVAL);
2637 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2638 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2641 if (spec->channel_mode) {
2642 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2643 for (i = 0; i < spec->num_channel_mode; i++) {
2644 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2645 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2650 /* SPDIF for stream index #1 */
2651 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2652 codec->num_pcms = 2;
2653 info = spec->pcm_rec + 1;
2654 info->name = spec->stream_name_digital;
2655 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2656 if (spec->multiout.dig_out_nid &&
2657 spec->stream_digital_playback) {
2658 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2659 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2661 if (spec->dig_in_nid &&
2662 spec->stream_digital_capture) {
2663 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2664 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2668 /* If the use of more than one ADC is requested for the current
2669 * model, configure a second analog capture-only PCM.
2671 /* Additional Analaog capture for index #2 */
2672 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
2673 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
2674 codec->num_pcms = 3;
2675 info = spec->pcm_rec + 2;
2676 info->name = spec->stream_name_analog;
2677 if (spec->alt_dac_nid) {
2678 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2679 *spec->stream_analog_alt_playback;
2680 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2683 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2684 alc_pcm_null_stream;
2685 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2687 if (spec->num_adc_nids > 1) {
2688 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2689 *spec->stream_analog_alt_capture;
2690 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2692 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2693 spec->num_adc_nids - 1;
2695 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2696 alc_pcm_null_stream;
2697 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2704 static void alc_free(struct hda_codec *codec)
2706 struct alc_spec *spec = codec->spec;
2712 if (spec->kctl_alloc) {
2713 for (i = 0; i < spec->num_kctl_used; i++)
2714 kfree(spec->kctl_alloc[i].name);
2715 kfree(spec->kctl_alloc);
2718 codec->spec = NULL; /* to be sure */
2723 static struct hda_codec_ops alc_patch_ops = {
2724 .build_controls = alc_build_controls,
2725 .build_pcms = alc_build_pcms,
2728 .unsol_event = alc_unsol_event,
2729 #ifdef CONFIG_SND_HDA_POWER_SAVE
2730 .check_power_status = alc_check_power_status,
2736 * Test configuration for debugging
2738 * Almost all inputs/outputs are enabled. I/O pins can be configured via
2741 #ifdef CONFIG_SND_DEBUG
2742 static hda_nid_t alc880_test_dac_nids[4] = {
2743 0x02, 0x03, 0x04, 0x05
2746 static struct hda_input_mux alc880_test_capture_source = {
2755 { "Surround", 0x6 },
2759 static struct hda_channel_mode alc880_test_modes[4] = {
2766 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2767 struct snd_ctl_elem_info *uinfo)
2769 static char *texts[] = {
2770 "N/A", "Line Out", "HP Out",
2771 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2773 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2775 uinfo->value.enumerated.items = 8;
2776 if (uinfo->value.enumerated.item >= 8)
2777 uinfo->value.enumerated.item = 7;
2778 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2782 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
2783 struct snd_ctl_elem_value *ucontrol)
2785 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2786 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2787 unsigned int pin_ctl, item = 0;
2789 pin_ctl = snd_hda_codec_read(codec, nid, 0,
2790 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2791 if (pin_ctl & AC_PINCTL_OUT_EN) {
2792 if (pin_ctl & AC_PINCTL_HP_EN)
2796 } else if (pin_ctl & AC_PINCTL_IN_EN) {
2797 switch (pin_ctl & AC_PINCTL_VREFEN) {
2798 case AC_PINCTL_VREF_HIZ: item = 3; break;
2799 case AC_PINCTL_VREF_50: item = 4; break;
2800 case AC_PINCTL_VREF_GRD: item = 5; break;
2801 case AC_PINCTL_VREF_80: item = 6; break;
2802 case AC_PINCTL_VREF_100: item = 7; break;
2805 ucontrol->value.enumerated.item[0] = item;
2809 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2810 struct snd_ctl_elem_value *ucontrol)
2812 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2813 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2814 static unsigned int ctls[] = {
2815 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2816 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2817 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2818 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2819 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2820 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2822 unsigned int old_ctl, new_ctl;
2824 old_ctl = snd_hda_codec_read(codec, nid, 0,
2825 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2826 new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2827 if (old_ctl != new_ctl) {
2829 snd_hda_codec_write_cache(codec, nid, 0,
2830 AC_VERB_SET_PIN_WIDGET_CONTROL,
2832 val = ucontrol->value.enumerated.item[0] >= 3 ?
2834 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2841 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2842 struct snd_ctl_elem_info *uinfo)
2844 static char *texts[] = {
2845 "Front", "Surround", "CLFE", "Side"
2847 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2849 uinfo->value.enumerated.items = 4;
2850 if (uinfo->value.enumerated.item >= 4)
2851 uinfo->value.enumerated.item = 3;
2852 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2856 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2857 struct snd_ctl_elem_value *ucontrol)
2859 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2860 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2863 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2864 ucontrol->value.enumerated.item[0] = sel & 3;
2868 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
2869 struct snd_ctl_elem_value *ucontrol)
2871 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2872 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2875 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
2876 if (ucontrol->value.enumerated.item[0] != sel) {
2877 sel = ucontrol->value.enumerated.item[0] & 3;
2878 snd_hda_codec_write_cache(codec, nid, 0,
2879 AC_VERB_SET_CONNECT_SEL, sel);
2885 #define PIN_CTL_TEST(xname,nid) { \
2886 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2888 .info = alc_test_pin_ctl_info, \
2889 .get = alc_test_pin_ctl_get, \
2890 .put = alc_test_pin_ctl_put, \
2891 .private_value = nid \
2894 #define PIN_SRC_TEST(xname,nid) { \
2895 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2897 .info = alc_test_pin_src_info, \
2898 .get = alc_test_pin_src_get, \
2899 .put = alc_test_pin_src_put, \
2900 .private_value = nid \
2903 static struct snd_kcontrol_new alc880_test_mixer[] = {
2904 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2905 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2906 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
2907 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2908 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2909 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2910 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
2911 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2912 PIN_CTL_TEST("Front Pin Mode", 0x14),
2913 PIN_CTL_TEST("Surround Pin Mode", 0x15),
2914 PIN_CTL_TEST("CLFE Pin Mode", 0x16),
2915 PIN_CTL_TEST("Side Pin Mode", 0x17),
2916 PIN_CTL_TEST("In-1 Pin Mode", 0x18),
2917 PIN_CTL_TEST("In-2 Pin Mode", 0x19),
2918 PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
2919 PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
2920 PIN_SRC_TEST("In-1 Pin Source", 0x18),
2921 PIN_SRC_TEST("In-2 Pin Source", 0x19),
2922 PIN_SRC_TEST("In-3 Pin Source", 0x1a),
2923 PIN_SRC_TEST("In-4 Pin Source", 0x1b),
2924 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
2925 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
2926 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
2927 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
2928 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
2929 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
2930 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
2931 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
2932 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
2933 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
2935 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2936 .name = "Channel Mode",
2937 .info = alc_ch_mode_info,
2938 .get = alc_ch_mode_get,
2939 .put = alc_ch_mode_put,
2944 static struct hda_verb alc880_test_init_verbs[] = {
2945 /* Unmute inputs of 0x0c - 0x0f */
2946 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2947 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2948 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2949 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2950 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2951 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2952 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2953 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2954 /* Vol output for 0x0c-0x0f */
2955 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2956 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2957 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2958 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2959 /* Set output pins 0x14-0x17 */
2960 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2961 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2962 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2963 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2964 /* Unmute output pins 0x14-0x17 */
2965 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2966 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2967 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2968 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2969 /* Set input pins 0x18-0x1c */
2970 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2971 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2972 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2973 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2974 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2975 /* Mute input pins 0x18-0x1b */
2976 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2977 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2978 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2979 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2981 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2982 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2983 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2984 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2985 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2986 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2987 /* Analog input/passthru */
2988 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2989 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2990 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2991 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2992 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3000 static const char *alc880_models[ALC880_MODEL_LAST] = {
3001 [ALC880_3ST] = "3stack",
3002 [ALC880_TCL_S700] = "tcl",
3003 [ALC880_3ST_DIG] = "3stack-digout",
3004 [ALC880_CLEVO] = "clevo",
3005 [ALC880_5ST] = "5stack",
3006 [ALC880_5ST_DIG] = "5stack-digout",
3007 [ALC880_W810] = "w810",
3008 [ALC880_Z71V] = "z71v",
3009 [ALC880_6ST] = "6stack",
3010 [ALC880_6ST_DIG] = "6stack-digout",
3011 [ALC880_ASUS] = "asus",
3012 [ALC880_ASUS_W1V] = "asus-w1v",
3013 [ALC880_ASUS_DIG] = "asus-dig",
3014 [ALC880_ASUS_DIG2] = "asus-dig2",
3015 [ALC880_UNIWILL_DIG] = "uniwill",
3016 [ALC880_UNIWILL_P53] = "uniwill-p53",
3017 [ALC880_FUJITSU] = "fujitsu",
3018 [ALC880_F1734] = "F1734",
3020 [ALC880_LG_LW] = "lg-lw",
3021 [ALC880_MEDION_RIM] = "medion",
3022 #ifdef CONFIG_SND_DEBUG
3023 [ALC880_TEST] = "test",
3025 [ALC880_AUTO] = "auto",
3028 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3029 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3030 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3031 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3032 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3033 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3034 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3035 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3036 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3037 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3038 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3039 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3040 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3041 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3042 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3043 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3044 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3045 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3046 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3047 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3048 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3049 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3050 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3051 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3052 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3053 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3054 SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
3055 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3056 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3057 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3058 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3059 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3060 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3061 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3062 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3063 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3064 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3065 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3066 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3067 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3068 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3069 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3070 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3071 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3072 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3073 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3074 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3075 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3076 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3077 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3078 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3079 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3080 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3081 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3082 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3083 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3084 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3085 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3086 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3087 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3088 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3089 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3090 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3091 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3092 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3093 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3094 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3095 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3096 SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
3097 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3098 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3103 * ALC880 codec presets
3105 static struct alc_config_preset alc880_presets[] = {
3107 .mixers = { alc880_three_stack_mixer },
3108 .init_verbs = { alc880_volume_init_verbs,
3109 alc880_pin_3stack_init_verbs },
3110 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3111 .dac_nids = alc880_dac_nids,
3112 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3113 .channel_mode = alc880_threestack_modes,
3115 .input_mux = &alc880_capture_source,
3117 [ALC880_3ST_DIG] = {
3118 .mixers = { alc880_three_stack_mixer },
3119 .init_verbs = { alc880_volume_init_verbs,
3120 alc880_pin_3stack_init_verbs },
3121 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3122 .dac_nids = alc880_dac_nids,
3123 .dig_out_nid = ALC880_DIGOUT_NID,
3124 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3125 .channel_mode = alc880_threestack_modes,
3127 .input_mux = &alc880_capture_source,
3129 [ALC880_TCL_S700] = {
3130 .mixers = { alc880_tcl_s700_mixer },
3131 .init_verbs = { alc880_volume_init_verbs,
3132 alc880_pin_tcl_S700_init_verbs,
3133 alc880_gpio2_init_verbs },
3134 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3135 .dac_nids = alc880_dac_nids,
3137 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3138 .channel_mode = alc880_2_jack_modes,
3139 .input_mux = &alc880_capture_source,
3142 .mixers = { alc880_three_stack_mixer,
3143 alc880_five_stack_mixer},
3144 .init_verbs = { alc880_volume_init_verbs,
3145 alc880_pin_5stack_init_verbs },
3146 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3147 .dac_nids = alc880_dac_nids,
3148 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3149 .channel_mode = alc880_fivestack_modes,
3150 .input_mux = &alc880_capture_source,
3152 [ALC880_5ST_DIG] = {
3153 .mixers = { alc880_three_stack_mixer,
3154 alc880_five_stack_mixer },
3155 .init_verbs = { alc880_volume_init_verbs,
3156 alc880_pin_5stack_init_verbs },
3157 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3158 .dac_nids = alc880_dac_nids,
3159 .dig_out_nid = ALC880_DIGOUT_NID,
3160 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3161 .channel_mode = alc880_fivestack_modes,
3162 .input_mux = &alc880_capture_source,
3165 .mixers = { alc880_six_stack_mixer },
3166 .init_verbs = { alc880_volume_init_verbs,
3167 alc880_pin_6stack_init_verbs },
3168 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3169 .dac_nids = alc880_6st_dac_nids,
3170 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3171 .channel_mode = alc880_sixstack_modes,
3172 .input_mux = &alc880_6stack_capture_source,
3174 [ALC880_6ST_DIG] = {
3175 .mixers = { alc880_six_stack_mixer },
3176 .init_verbs = { alc880_volume_init_verbs,
3177 alc880_pin_6stack_init_verbs },
3178 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3179 .dac_nids = alc880_6st_dac_nids,
3180 .dig_out_nid = ALC880_DIGOUT_NID,
3181 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3182 .channel_mode = alc880_sixstack_modes,
3183 .input_mux = &alc880_6stack_capture_source,
3186 .mixers = { alc880_w810_base_mixer },
3187 .init_verbs = { alc880_volume_init_verbs,
3188 alc880_pin_w810_init_verbs,
3189 alc880_gpio2_init_verbs },
3190 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3191 .dac_nids = alc880_w810_dac_nids,
3192 .dig_out_nid = ALC880_DIGOUT_NID,
3193 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3194 .channel_mode = alc880_w810_modes,
3195 .input_mux = &alc880_capture_source,
3198 .mixers = { alc880_z71v_mixer },
3199 .init_verbs = { alc880_volume_init_verbs,
3200 alc880_pin_z71v_init_verbs },
3201 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3202 .dac_nids = alc880_z71v_dac_nids,
3203 .dig_out_nid = ALC880_DIGOUT_NID,
3205 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3206 .channel_mode = alc880_2_jack_modes,
3207 .input_mux = &alc880_capture_source,
3210 .mixers = { alc880_f1734_mixer },
3211 .init_verbs = { alc880_volume_init_verbs,
3212 alc880_pin_f1734_init_verbs },
3213 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3214 .dac_nids = alc880_f1734_dac_nids,
3216 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3217 .channel_mode = alc880_2_jack_modes,
3218 .input_mux = &alc880_f1734_capture_source,
3219 .unsol_event = alc880_uniwill_p53_unsol_event,
3220 .init_hook = alc880_uniwill_p53_hp_automute,
3223 .mixers = { alc880_asus_mixer },
3224 .init_verbs = { alc880_volume_init_verbs,
3225 alc880_pin_asus_init_verbs,
3226 alc880_gpio1_init_verbs },
3227 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3228 .dac_nids = alc880_asus_dac_nids,
3229 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3230 .channel_mode = alc880_asus_modes,
3232 .input_mux = &alc880_capture_source,
3234 [ALC880_ASUS_DIG] = {
3235 .mixers = { alc880_asus_mixer },
3236 .init_verbs = { alc880_volume_init_verbs,
3237 alc880_pin_asus_init_verbs,
3238 alc880_gpio1_init_verbs },
3239 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3240 .dac_nids = alc880_asus_dac_nids,
3241 .dig_out_nid = ALC880_DIGOUT_NID,
3242 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3243 .channel_mode = alc880_asus_modes,
3245 .input_mux = &alc880_capture_source,
3247 [ALC880_ASUS_DIG2] = {
3248 .mixers = { alc880_asus_mixer },
3249 .init_verbs = { alc880_volume_init_verbs,
3250 alc880_pin_asus_init_verbs,
3251 alc880_gpio2_init_verbs }, /* use GPIO2 */
3252 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3253 .dac_nids = alc880_asus_dac_nids,
3254 .dig_out_nid = ALC880_DIGOUT_NID,
3255 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3256 .channel_mode = alc880_asus_modes,
3258 .input_mux = &alc880_capture_source,
3260 [ALC880_ASUS_W1V] = {
3261 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3262 .init_verbs = { alc880_volume_init_verbs,
3263 alc880_pin_asus_init_verbs,
3264 alc880_gpio1_init_verbs },
3265 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3266 .dac_nids = alc880_asus_dac_nids,
3267 .dig_out_nid = ALC880_DIGOUT_NID,
3268 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3269 .channel_mode = alc880_asus_modes,
3271 .input_mux = &alc880_capture_source,
3273 [ALC880_UNIWILL_DIG] = {
3274 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3275 .init_verbs = { alc880_volume_init_verbs,
3276 alc880_pin_asus_init_verbs },
3277 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3278 .dac_nids = alc880_asus_dac_nids,
3279 .dig_out_nid = ALC880_DIGOUT_NID,
3280 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3281 .channel_mode = alc880_asus_modes,
3283 .input_mux = &alc880_capture_source,
3285 [ALC880_UNIWILL] = {
3286 .mixers = { alc880_uniwill_mixer },
3287 .init_verbs = { alc880_volume_init_verbs,
3288 alc880_uniwill_init_verbs },
3289 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3290 .dac_nids = alc880_asus_dac_nids,
3291 .dig_out_nid = ALC880_DIGOUT_NID,
3292 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3293 .channel_mode = alc880_threestack_modes,
3295 .input_mux = &alc880_capture_source,
3296 .unsol_event = alc880_uniwill_unsol_event,
3297 .init_hook = alc880_uniwill_automute,
3299 [ALC880_UNIWILL_P53] = {
3300 .mixers = { alc880_uniwill_p53_mixer },
3301 .init_verbs = { alc880_volume_init_verbs,
3302 alc880_uniwill_p53_init_verbs },
3303 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3304 .dac_nids = alc880_asus_dac_nids,
3305 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3306 .channel_mode = alc880_threestack_modes,
3307 .input_mux = &alc880_capture_source,
3308 .unsol_event = alc880_uniwill_p53_unsol_event,
3309 .init_hook = alc880_uniwill_p53_hp_automute,
3311 [ALC880_FUJITSU] = {
3312 .mixers = { alc880_fujitsu_mixer,
3313 alc880_pcbeep_mixer, },
3314 .init_verbs = { alc880_volume_init_verbs,
3315 alc880_uniwill_p53_init_verbs,
3316 alc880_beep_init_verbs },
3317 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3318 .dac_nids = alc880_dac_nids,
3319 .dig_out_nid = ALC880_DIGOUT_NID,
3320 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3321 .channel_mode = alc880_2_jack_modes,
3322 .input_mux = &alc880_capture_source,
3323 .unsol_event = alc880_uniwill_p53_unsol_event,
3324 .init_hook = alc880_uniwill_p53_hp_automute,
3327 .mixers = { alc880_three_stack_mixer },
3328 .init_verbs = { alc880_volume_init_verbs,
3329 alc880_pin_clevo_init_verbs },
3330 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3331 .dac_nids = alc880_dac_nids,
3333 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3334 .channel_mode = alc880_threestack_modes,
3336 .input_mux = &alc880_capture_source,
3339 .mixers = { alc880_lg_mixer },
3340 .init_verbs = { alc880_volume_init_verbs,
3341 alc880_lg_init_verbs },
3342 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3343 .dac_nids = alc880_lg_dac_nids,
3344 .dig_out_nid = ALC880_DIGOUT_NID,
3345 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3346 .channel_mode = alc880_lg_ch_modes,
3348 .input_mux = &alc880_lg_capture_source,
3349 .unsol_event = alc880_lg_unsol_event,
3350 .init_hook = alc880_lg_automute,
3351 #ifdef CONFIG_SND_HDA_POWER_SAVE
3352 .loopbacks = alc880_lg_loopbacks,
3356 .mixers = { alc880_lg_lw_mixer },
3357 .init_verbs = { alc880_volume_init_verbs,
3358 alc880_lg_lw_init_verbs },
3359 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3360 .dac_nids = alc880_dac_nids,
3361 .dig_out_nid = ALC880_DIGOUT_NID,
3362 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3363 .channel_mode = alc880_lg_lw_modes,
3364 .input_mux = &alc880_lg_lw_capture_source,
3365 .unsol_event = alc880_lg_lw_unsol_event,
3366 .init_hook = alc880_lg_lw_automute,
3368 [ALC880_MEDION_RIM] = {
3369 .mixers = { alc880_medion_rim_mixer },
3370 .init_verbs = { alc880_volume_init_verbs,
3371 alc880_medion_rim_init_verbs,
3372 alc_gpio2_init_verbs },
3373 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3374 .dac_nids = alc880_dac_nids,
3375 .dig_out_nid = ALC880_DIGOUT_NID,
3376 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3377 .channel_mode = alc880_2_jack_modes,
3378 .input_mux = &alc880_medion_rim_capture_source,
3379 .unsol_event = alc880_medion_rim_unsol_event,
3380 .init_hook = alc880_medion_rim_automute,
3382 #ifdef CONFIG_SND_DEBUG
3384 .mixers = { alc880_test_mixer },
3385 .init_verbs = { alc880_test_init_verbs },
3386 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3387 .dac_nids = alc880_test_dac_nids,
3388 .dig_out_nid = ALC880_DIGOUT_NID,
3389 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3390 .channel_mode = alc880_test_modes,
3391 .input_mux = &alc880_test_capture_source,
3397 * Automatic parse of I/O pins from the BIOS configuration
3400 #define NUM_CONTROL_ALLOC 32
3401 #define NUM_VERB_ALLOC 32
3405 ALC_CTL_WIDGET_MUTE,
3408 static struct snd_kcontrol_new alc880_control_templates[] = {
3409 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3410 HDA_CODEC_MUTE(NULL, 0, 0, 0),
3411 HDA_BIND_MUTE(NULL, 0, 0, 0),
3414 /* add dynamic controls */
3415 static int add_control(struct alc_spec *spec, int type, const char *name,
3418 struct snd_kcontrol_new *knew;
3420 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
3421 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
3423 /* array + terminator */
3424 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
3427 if (spec->kctl_alloc) {
3428 memcpy(knew, spec->kctl_alloc,
3429 sizeof(*knew) * spec->num_kctl_alloc);
3430 kfree(spec->kctl_alloc);
3432 spec->kctl_alloc = knew;
3433 spec->num_kctl_alloc = num;
3436 knew = &spec->kctl_alloc[spec->num_kctl_used];
3437 *knew = alc880_control_templates[type];
3438 knew->name = kstrdup(name, GFP_KERNEL);
3441 knew->private_value = val;
3442 spec->num_kctl_used++;
3446 #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17)
3447 #define alc880_fixed_pin_idx(nid) ((nid) - 0x14)
3448 #define alc880_is_multi_pin(nid) ((nid) >= 0x18)
3449 #define alc880_multi_pin_idx(nid) ((nid) - 0x18)
3450 #define alc880_is_input_pin(nid) ((nid) >= 0x18)
3451 #define alc880_input_pin_idx(nid) ((nid) - 0x18)
3452 #define alc880_idx_to_dac(nid) ((nid) + 0x02)
3453 #define alc880_dac_to_idx(nid) ((nid) - 0x02)
3454 #define alc880_idx_to_mixer(nid) ((nid) + 0x0c)
3455 #define alc880_idx_to_selector(nid) ((nid) + 0x10)
3456 #define ALC880_PIN_CD_NID 0x1c
3458 /* fill in the dac_nids table from the parsed pin configuration */
3459 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3460 const struct auto_pin_cfg *cfg)
3466 memset(assigned, 0, sizeof(assigned));
3467 spec->multiout.dac_nids = spec->private_dac_nids;
3469 /* check the pins hardwired to audio widget */
3470 for (i = 0; i < cfg->line_outs; i++) {
3471 nid = cfg->line_out_pins[i];
3472 if (alc880_is_fixed_pin(nid)) {
3473 int idx = alc880_fixed_pin_idx(nid);
3474 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3478 /* left pins can be connect to any audio widget */
3479 for (i = 0; i < cfg->line_outs; i++) {
3480 nid = cfg->line_out_pins[i];
3481 if (alc880_is_fixed_pin(nid))
3483 /* search for an empty channel */
3484 for (j = 0; j < cfg->line_outs; j++) {
3486 spec->multiout.dac_nids[i] =
3487 alc880_idx_to_dac(j);
3493 spec->multiout.num_dacs = cfg->line_outs;
3497 /* add playback controls from the parsed DAC table */
3498 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3499 const struct auto_pin_cfg *cfg)
3502 static const char *chname[4] = {
3503 "Front", "Surround", NULL /*CLFE*/, "Side"
3508 for (i = 0; i < cfg->line_outs; i++) {
3509 if (!spec->multiout.dac_nids[i])
3511 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3514 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3515 "Center Playback Volume",
3516 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3520 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3521 "LFE Playback Volume",
3522 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
3526 err = add_control(spec, ALC_CTL_BIND_MUTE,
3527 "Center Playback Switch",
3528 HDA_COMPOSE_AMP_VAL(nid, 1, 2,
3532 err = add_control(spec, ALC_CTL_BIND_MUTE,
3533 "LFE Playback Switch",
3534 HDA_COMPOSE_AMP_VAL(nid, 2, 2,
3539 sprintf(name, "%s Playback Volume", chname[i]);
3540 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3541 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3545 sprintf(name, "%s Playback Switch", chname[i]);
3546 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3547 HDA_COMPOSE_AMP_VAL(nid, 3, 2,
3556 /* add playback controls for speaker and HP outputs */
3557 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
3567 if (alc880_is_fixed_pin(pin)) {
3568 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
3569 /* specify the DAC as the extra output */
3570 if (!spec->multiout.hp_nid)
3571 spec->multiout.hp_nid = nid;
3573 spec->multiout.extra_out_nid[0] = nid;
3574 /* control HP volume/switch on the output mixer amp */
3575 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
3576 sprintf(name, "%s Playback Volume", pfx);
3577 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3578 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3581 sprintf(name, "%s Playback Switch", pfx);
3582 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3583 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
3586 } else if (alc880_is_multi_pin(pin)) {
3587 /* set manual connection */
3588 /* we have only a switch on HP-out PIN */
3589 sprintf(name, "%s Playback Switch", pfx);
3590 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3591 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3598 /* create input playback/capture controls for the given pin */
3599 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
3600 const char *ctlname,
3601 int idx, hda_nid_t mix_nid)
3606 sprintf(name, "%s Playback Volume", ctlname);
3607 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3608 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3611 sprintf(name, "%s Playback Switch", ctlname);
3612 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3613 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3619 /* create playback/capture controls for input pins */
3620 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3621 const struct auto_pin_cfg *cfg)
3623 struct hda_input_mux *imux = &spec->private_imux;
3626 for (i = 0; i < AUTO_PIN_LAST; i++) {
3627 if (alc880_is_input_pin(cfg->input_pins[i])) {
3628 idx = alc880_input_pin_idx(cfg->input_pins[i]);
3629 err = new_analog_input(spec, cfg->input_pins[i],
3630 auto_pin_cfg_labels[i],
3634 imux->items[imux->num_items].label =
3635 auto_pin_cfg_labels[i];
3636 imux->items[imux->num_items].index =
3637 alc880_input_pin_idx(cfg->input_pins[i]);
3644 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
3645 unsigned int pin_type)
3647 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3650 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3654 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3655 hda_nid_t nid, int pin_type,
3658 alc_set_pin_output(codec, nid, pin_type);
3659 /* need the manual connection? */
3660 if (alc880_is_multi_pin(nid)) {
3661 struct alc_spec *spec = codec->spec;
3662 int idx = alc880_multi_pin_idx(nid);
3663 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3664 AC_VERB_SET_CONNECT_SEL,
3665 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3669 static int get_pin_type(int line_out_type)
3671 if (line_out_type == AUTO_PIN_HP_OUT)
3677 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3679 struct alc_spec *spec = codec->spec;
3682 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3683 for (i = 0; i < spec->autocfg.line_outs; i++) {
3684 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3685 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3686 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
3690 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3692 struct alc_spec *spec = codec->spec;
3695 pin = spec->autocfg.speaker_pins[0];
3696 if (pin) /* connect to front */
3697 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3698 pin = spec->autocfg.hp_pins[0];
3699 if (pin) /* connect to front */
3700 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3703 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3705 struct alc_spec *spec = codec->spec;
3708 for (i = 0; i < AUTO_PIN_LAST; i++) {
3709 hda_nid_t nid = spec->autocfg.input_pins[i];
3710 if (alc880_is_input_pin(nid)) {
3711 snd_hda_codec_write(codec, nid, 0,
3712 AC_VERB_SET_PIN_WIDGET_CONTROL,
3713 i <= AUTO_PIN_FRONT_MIC ?
3714 PIN_VREF80 : PIN_IN);
3715 if (nid != ALC880_PIN_CD_NID)
3716 snd_hda_codec_write(codec, nid, 0,
3717 AC_VERB_SET_AMP_GAIN_MUTE,
3723 /* parse the BIOS configuration and set up the alc_spec */
3724 /* return 1 if successful, 0 if the proper config is not found,
3725 * or a negative error code
3727 static int alc880_parse_auto_config(struct hda_codec *codec)
3729 struct alc_spec *spec = codec->spec;
3731 static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3733 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3737 if (!spec->autocfg.line_outs)
3738 return 0; /* can't find valid BIOS pin config */
3740 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
3743 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
3746 err = alc880_auto_create_extra_out(spec,
3747 spec->autocfg.speaker_pins[0],
3751 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3755 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
3759 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3761 if (spec->autocfg.dig_out_pin)
3762 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3763 if (spec->autocfg.dig_in_pin)
3764 spec->dig_in_nid = ALC880_DIGIN_NID;
3766 if (spec->kctl_alloc)
3767 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3769 spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3771 spec->num_mux_defs = 1;
3772 spec->input_mux = &spec->private_imux;
3777 /* additional initialization for auto-configuration model */
3778 static void alc880_auto_init(struct hda_codec *codec)
3780 struct alc_spec *spec = codec->spec;
3781 alc880_auto_init_multi_out(codec);
3782 alc880_auto_init_extra_out(codec);
3783 alc880_auto_init_analog_input(codec);
3784 if (spec->unsol_event)
3785 alc_sku_automute(codec);
3789 * OK, here we have finally the patch for ALC880
3792 static int patch_alc880(struct hda_codec *codec)
3794 struct alc_spec *spec;
3798 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3804 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3807 if (board_config < 0) {
3808 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3809 "trying auto-probe from BIOS...\n");
3810 board_config = ALC880_AUTO;
3813 if (board_config == ALC880_AUTO) {
3814 /* automatic parse from the BIOS config */
3815 err = alc880_parse_auto_config(codec);
3821 "hda_codec: Cannot set up configuration "
3822 "from BIOS. Using 3-stack mode...\n");
3823 board_config = ALC880_3ST;
3827 if (board_config != ALC880_AUTO)
3828 setup_preset(spec, &alc880_presets[board_config]);
3830 spec->stream_name_analog = "ALC880 Analog";
3831 spec->stream_analog_playback = &alc880_pcm_analog_playback;
3832 spec->stream_analog_capture = &alc880_pcm_analog_capture;
3833 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
3835 spec->stream_name_digital = "ALC880 Digital";
3836 spec->stream_digital_playback = &alc880_pcm_digital_playback;
3837 spec->stream_digital_capture = &alc880_pcm_digital_capture;
3839 if (!spec->adc_nids && spec->input_mux) {
3840 /* check whether NID 0x07 is valid */
3841 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3843 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3844 if (wcap != AC_WID_AUD_IN) {
3845 spec->adc_nids = alc880_adc_nids_alt;
3846 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3847 spec->mixers[spec->num_mixers] =
3848 alc880_capture_alt_mixer;
3851 spec->adc_nids = alc880_adc_nids;
3852 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3853 spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3858 spec->vmaster_nid = 0x0c;
3860 codec->patch_ops = alc_patch_ops;
3861 if (board_config == ALC880_AUTO)
3862 spec->init_hook = alc880_auto_init;
3863 #ifdef CONFIG_SND_HDA_POWER_SAVE
3864 if (!spec->loopback.amplist)
3865 spec->loopback.amplist = alc880_loopbacks;
3876 static hda_nid_t alc260_dac_nids[1] = {
3881 static hda_nid_t alc260_adc_nids[1] = {
3886 static hda_nid_t alc260_adc_nids_alt[1] = {
3891 static hda_nid_t alc260_hp_adc_nids[2] = {
3896 /* NIDs used when simultaneous access to both ADCs makes sense. Note that
3897 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
3899 static hda_nid_t alc260_dual_adc_nids[2] = {
3904 #define ALC260_DIGOUT_NID 0x03
3905 #define ALC260_DIGIN_NID 0x06
3907 static struct hda_input_mux alc260_capture_source = {
3911 { "Front Mic", 0x1 },
3917 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
3918 * headphone jack and the internal CD lines since these are the only pins at
3919 * which audio can appear. For flexibility, also allow the option of
3920 * recording the mixer output on the second ADC (ADC0 doesn't have a
3921 * connection to the mixer output).
3923 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
3927 { "Mic/Line", 0x0 },
3929 { "Headphone", 0x2 },
3935 { "Mic/Line", 0x0 },
3937 { "Headphone", 0x2 },
3944 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
3945 * the Fujitsu S702x, but jacks are marked differently.
3947 static struct hda_input_mux alc260_acer_capture_sources[2] = {
3954 { "Headphone", 0x5 },
3963 { "Headphone", 0x6 },
3969 * This is just place-holder, so there's something for alc_build_pcms to look
3970 * at when it calculates the maximum number of channels. ALC260 has no mixer
3971 * element which allows changing the channel mode, so the verb list is
3974 static struct hda_channel_mode alc260_modes[1] = {
3979 /* Mixer combinations
3981 * basic: base_output + input + pc_beep + capture
3982 * HP: base_output + input + capture_alt
3983 * HP_3013: hp_3013 + input + capture
3984 * fujitsu: fujitsu + capture
3985 * acer: acer + capture
3988 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
3989 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3990 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
3991 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3992 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
3993 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3994 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3998 static struct snd_kcontrol_new alc260_input_mixer[] = {
3999 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4000 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4001 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4002 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4003 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4004 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4005 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4006 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4010 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
4011 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
4012 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
4016 /* update HP, line and mono out pins according to the master switch */
4017 static void alc260_hp_master_update(struct hda_codec *codec,
4018 hda_nid_t hp, hda_nid_t line,
4021 struct alc_spec *spec = codec->spec;
4022 unsigned int val = spec->master_sw ? PIN_HP : 0;
4023 /* change HP and line-out pins */
4024 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4026 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4028 /* mono (speaker) depending on the HP jack sense */
4029 val = (val && !spec->jack_present) ? PIN_OUT : 0;
4030 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4034 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4035 struct snd_ctl_elem_value *ucontrol)
4037 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4038 struct alc_spec *spec = codec->spec;
4039 *ucontrol->value.integer.value = spec->master_sw;
4043 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4044 struct snd_ctl_elem_value *ucontrol)
4046 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4047 struct alc_spec *spec = codec->spec;
4048 int val = !!*ucontrol->value.integer.value;
4049 hda_nid_t hp, line, mono;
4051 if (val == spec->master_sw)
4053 spec->master_sw = val;
4054 hp = (kcontrol->private_value >> 16) & 0xff;
4055 line = (kcontrol->private_value >> 8) & 0xff;
4056 mono = kcontrol->private_value & 0xff;
4057 alc260_hp_master_update(codec, hp, line, mono);
4061 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4063 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4064 .name = "Master Playback Switch",
4065 .info = snd_ctl_boolean_mono_info,
4066 .get = alc260_hp_master_sw_get,
4067 .put = alc260_hp_master_sw_put,
4068 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4070 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4071 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4072 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4073 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4074 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4076 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4080 static struct hda_verb alc260_hp_unsol_verbs[] = {
4081 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4085 static void alc260_hp_automute(struct hda_codec *codec)
4087 struct alc_spec *spec = codec->spec;
4088 unsigned int present;
4090 present = snd_hda_codec_read(codec, 0x10, 0,
4091 AC_VERB_GET_PIN_SENSE, 0);
4092 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4093 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4096 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4098 if ((res >> 26) == ALC880_HP_EVENT)
4099 alc260_hp_automute(codec);
4102 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4104 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4105 .name = "Master Playback Switch",
4106 .info = snd_ctl_boolean_mono_info,
4107 .get = alc260_hp_master_sw_get,
4108 .put = alc260_hp_master_sw_put,
4109 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
4111 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4112 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4113 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4114 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4115 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4116 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4117 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4118 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4122 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4123 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4127 static void alc260_hp_3013_automute(struct hda_codec *codec)
4129 struct alc_spec *spec = codec->spec;
4130 unsigned int present;
4132 present = snd_hda_codec_read(codec, 0x15, 0,
4133 AC_VERB_GET_PIN_SENSE, 0);
4134 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4135 alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
4138 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4141 if ((res >> 26) == ALC880_HP_EVENT)
4142 alc260_hp_3013_automute(codec);
4145 /* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12,
4146 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10.
4148 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4149 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4150 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4151 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4152 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4153 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4154 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4155 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4156 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4157 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4158 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4159 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4160 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4164 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current
4165 * versions of the ALC260 don't act on requests to enable mic bias from NID
4166 * 0x0f (used to drive the headphone jack in these laptops). The ALC260
4167 * datasheet doesn't mention this restriction. At this stage it's not clear
4168 * whether this behaviour is intentional or is a hardware bug in chip
4169 * revisions available in early 2006. Therefore for now allow the
4170 * "Headphone Jack Mode" control to span all choices, but if it turns out
4171 * that the lack of mic bias for this NID is intentional we could change the
4172 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4174 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4175 * don't appear to make the mic bias available from the "line" jack, even
4176 * though the NID used for this jack (0x14) can supply it. The theory is
4177 * that perhaps Acer have included blocking capacitors between the ALC260
4178 * and the output jack. If this turns out to be the case for all such
4179 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4180 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4182 * The C20x Tablet series have a mono internal speaker which is controlled
4183 * via the chip's Mono sum widget and pin complex, so include the necessary
4184 * controls for such models. On models without a "mono speaker" the control
4185 * won't do anything.
4187 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4188 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4189 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4190 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4191 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4193 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4195 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4196 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4197 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4198 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4199 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4200 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4201 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4202 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4203 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4204 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4208 /* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4209 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17.
4211 static struct snd_kcontrol_new alc260_will_mixer[] = {
4212 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4213 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4214 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4215 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4216 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4217 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4218 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4219 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4220 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4221 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4222 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4223 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4227 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4228 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4230 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4231 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4232 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4233 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4234 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4235 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4236 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4237 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4238 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4239 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4240 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4244 /* capture mixer elements */
4245 static struct snd_kcontrol_new alc260_capture_mixer[] = {
4246 HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
4247 HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
4248 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
4249 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
4251 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4252 /* The multiple "Capture Source" controls confuse alsamixer
4253 * So call somewhat different..
4255 /* .name = "Capture Source", */
4256 .name = "Input Source",
4258 .info = alc_mux_enum_info,
4259 .get = alc_mux_enum_get,
4260 .put = alc_mux_enum_put,
4265 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
4266 HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
4267 HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
4269 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4270 /* The multiple "Capture Source" controls confuse alsamixer
4271 * So call somewhat different..
4273 /* .name = "Capture Source", */
4274 .name = "Input Source",
4276 .info = alc_mux_enum_info,
4277 .get = alc_mux_enum_get,
4278 .put = alc_mux_enum_put,
4284 * initialization verbs
4286 static struct hda_verb alc260_init_verbs[] = {
4287 /* Line In pin widget for input */
4288 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4289 /* CD pin widget for input */
4290 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4291 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4292 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4293 /* Mic2 (front panel) pin widget for input and vref at 80% */
4294 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4295 /* LINE-2 is used for line-out in rear */
4296 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4297 /* select line-out */
4298 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4300 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4302 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4304 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4305 /* mute capture amp left and right */
4306 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4307 /* set connection select to line in (default select for this ADC) */
4308 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4309 /* mute capture amp left and right */
4310 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4311 /* set connection select to line in (default select for this ADC) */
4312 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4313 /* set vol=0 Line-Out mixer amp left and right */
4314 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4315 /* unmute pin widget amp left and right (no gain on this amp) */
4316 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4317 /* set vol=0 HP mixer amp left and right */
4318 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4319 /* unmute pin widget amp left and right (no gain on this amp) */
4320 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4321 /* set vol=0 Mono mixer amp left and right */
4322 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4323 /* unmute pin widget amp left and right (no gain on this amp) */
4324 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4325 /* unmute LINE-2 out pin */
4326 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4327 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4330 /* mute analog inputs */
4331 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4332 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4333 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4334 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4335 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4336 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4337 /* mute Front out path */
4338 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4339 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4340 /* mute Headphone out path */
4341 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4342 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4343 /* mute Mono out path */
4344 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4345 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4349 #if 0 /* should be identical with alc260_init_verbs? */
4350 static struct hda_verb alc260_hp_init_verbs[] = {
4351 /* Headphone and output */
4352 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4354 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4355 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4356 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4357 /* Mic2 (front panel) pin widget for input and vref at 80% */
4358 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4359 /* Line In pin widget for input */
4360 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4361 /* Line-2 pin widget for output */
4362 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4363 /* CD pin widget for input */
4364 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4365 /* unmute amp left and right */
4366 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4367 /* set connection select to line in (default select for this ADC) */
4368 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4369 /* unmute Line-Out mixer amp left and right (volume = 0) */
4370 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4371 /* mute pin widget amp left and right (no gain on this amp) */
4372 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4373 /* unmute HP mixer amp left and right (volume = 0) */
4374 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4375 /* mute pin widget amp left and right (no gain on this amp) */
4376 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4377 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4380 /* mute analog inputs */
4381 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4382 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4383 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4384 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4385 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4386 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4387 /* Unmute Front out path */
4388 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4389 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4390 /* Unmute Headphone out path */
4391 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4392 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4393 /* Unmute Mono out path */
4394 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4395 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4400 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4401 /* Line out and output */
4402 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4404 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4405 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4406 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4407 /* Mic2 (front panel) pin widget for input and vref at 80% */
4408 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4409 /* Line In pin widget for input */
4410 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4411 /* Headphone pin widget for output */
4412 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4413 /* CD pin widget for input */
4414 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4415 /* unmute amp left and right */
4416 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4417 /* set connection select to line in (default select for this ADC) */
4418 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4419 /* unmute Line-Out mixer amp left and right (volume = 0) */
4420 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4421 /* mute pin widget amp left and right (no gain on this amp) */
4422 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4423 /* unmute HP mixer amp left and right (volume = 0) */
4424 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4425 /* mute pin widget amp left and right (no gain on this amp) */
4426 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4427 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4430 /* mute analog inputs */
4431 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4432 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4433 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4434 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4435 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4436 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4437 /* Unmute Front out path */
4438 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4439 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4440 /* Unmute Headphone out path */
4441 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4442 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4443 /* Unmute Mono out path */
4444 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4445 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4449 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4450 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4451 * audio = 0x16, internal speaker = 0x10.
4453 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4454 /* Disable all GPIOs */
4455 {0x01, AC_VERB_SET_GPIO_MASK, 0},
4456 /* Internal speaker is connected to headphone pin */
4457 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4458 /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4459 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4460 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4461 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4462 /* Ensure all other unused pins are disabled and muted. */
4463 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4464 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4465 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4466 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4467 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4468 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4469 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4470 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4472 /* Disable digital (SPDIF) pins */
4473 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4474 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4476 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4477 * when acting as an output.
4479 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4481 /* Start with output sum widgets muted and their output gains at min */
4482 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4483 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4484 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4485 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4486 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4487 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4488 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4489 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4490 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4492 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4493 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4494 /* Unmute Line1 pin widget output buffer since it starts as an output.
4495 * If the pin mode is changed by the user the pin mode control will
4496 * take care of enabling the pin's input/output buffers as needed.
4497 * Therefore there's no need to enable the input buffer at this
4500 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4501 /* Unmute input buffer of pin widget used for Line-in (no equiv
4504 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4506 /* Mute capture amp left and right */
4507 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4508 /* Set ADC connection select to match default mixer setting - line
4511 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4513 /* Do the same for the second ADC: mute capture input amp and
4514 * set ADC connection to line in (on mic1 pin)
4516 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4517 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4519 /* Mute all inputs to mixer widget (even unconnected ones) */
4520 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4521 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4522 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4523 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4524 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4525 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4526 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4527 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4532 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
4533 * similar laptops (adapted from Fujitsu init verbs).
4535 static struct hda_verb alc260_acer_init_verbs[] = {
4536 /* On TravelMate laptops, GPIO 0 enables the internal speaker and
4537 * the headphone jack. Turn this on and rely on the standard mute
4538 * methods whenever the user wants to turn these outputs off.
4540 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4541 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4542 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4543 /* Internal speaker/Headphone jack is connected to Line-out pin */
4544 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4545 /* Internal microphone/Mic jack is connected to Mic1 pin */
4546 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
4547 /* Line In jack is connected to Line1 pin */
4548 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4549 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
4550 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4551 /* Ensure all other unused pins are disabled and muted. */
4552 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4553 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4554 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4555 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4556 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4557 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4558 /* Disable digital (SPDIF) pins */
4559 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4560 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4562 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
4563 * bus when acting as outputs.
4565 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4566 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4568 /* Start with output sum widgets muted and their output gains at min */
4569 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4570 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4571 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4572 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4573 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4574 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4575 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4576 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4577 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4579 /* Unmute Line-out pin widget amp left and right
4580 * (no equiv mixer ctrl)
4582 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4583 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
4584 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4585 /* Unmute Mic1 and Line1 pin widget input buffers since they start as
4586 * inputs. If the pin mode is changed by the user the pin mode control
4587 * will take care of enabling the pin's input/output buffers as needed.
4588 * Therefore there's no need to enable the input buffer at this
4591 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4592 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4594 /* Mute capture amp left and right */
4595 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4596 /* Set ADC connection select to match default mixer setting - mic
4599 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4601 /* Do similar with the second ADC: mute capture input amp and
4602 * set ADC connection to mic to match ALSA's default state.
4604 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4605 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4607 /* Mute all inputs to mixer widget (even unconnected ones) */
4608 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4609 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4610 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4611 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4612 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4613 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4614 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4615 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4620 static struct hda_verb alc260_will_verbs[] = {
4621 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4622 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
4623 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
4624 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4625 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4626 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
4630 static struct hda_verb alc260_replacer_672v_verbs[] = {
4631 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4632 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4633 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
4635 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4636 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4637 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4639 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4643 /* toggle speaker-output according to the hp-jack state */
4644 static void alc260_replacer_672v_automute(struct hda_codec *codec)
4646 unsigned int present;
4648 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
4649 present = snd_hda_codec_read(codec, 0x0f, 0,
4650 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
4652 snd_hda_codec_write_cache(codec, 0x01, 0,
4653 AC_VERB_SET_GPIO_DATA, 1);
4654 snd_hda_codec_write_cache(codec, 0x0f, 0,
4655 AC_VERB_SET_PIN_WIDGET_CONTROL,
4658 snd_hda_codec_write_cache(codec, 0x01, 0,
4659 AC_VERB_SET_GPIO_DATA, 0);
4660 snd_hda_codec_write_cache(codec, 0x0f, 0,
4661 AC_VERB_SET_PIN_WIDGET_CONTROL,
4666 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
4669 if ((res >> 26) == ALC880_HP_EVENT)
4670 alc260_replacer_672v_automute(codec);
4673 /* Test configuration for debugging, modelled after the ALC880 test
4676 #ifdef CONFIG_SND_DEBUG
4677 static hda_nid_t alc260_test_dac_nids[1] = {
4680 static hda_nid_t alc260_test_adc_nids[2] = {
4683 /* For testing the ALC260, each input MUX needs its own definition since
4684 * the signal assignments are different. This assumes that the first ADC
4687 static struct hda_input_mux alc260_test_capture_sources[2] = {
4691 { "MIC1 pin", 0x0 },
4692 { "MIC2 pin", 0x1 },
4693 { "LINE1 pin", 0x2 },
4694 { "LINE2 pin", 0x3 },
4696 { "LINE-OUT pin", 0x5 },
4697 { "HP-OUT pin", 0x6 },
4703 { "MIC1 pin", 0x0 },
4704 { "MIC2 pin", 0x1 },
4705 { "LINE1 pin", 0x2 },
4706 { "LINE2 pin", 0x3 },
4709 { "LINE-OUT pin", 0x6 },
4710 { "HP-OUT pin", 0x7 },
4714 static struct snd_kcontrol_new alc260_test_mixer[] = {
4715 /* Output driver widgets */
4716 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4717 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4718 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4719 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
4720 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4721 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
4723 /* Modes for retasking pin widgets
4724 * Note: the ALC260 doesn't seem to act on requests to enable mic
4725 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't
4726 * mention this restriction. At this stage it's not clear whether
4727 * this behaviour is intentional or is a hardware bug in chip
4728 * revisions available at least up until early 2006. Therefore for
4729 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
4730 * choices, but if it turns out that the lack of mic bias for these
4731 * NIDs is intentional we could change their modes from
4732 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4734 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
4735 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
4736 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
4737 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
4738 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
4739 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
4741 /* Loopback mixer controls */
4742 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
4743 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
4744 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
4745 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
4746 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
4747 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
4748 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
4749 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
4750 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4751 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4752 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4753 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4754 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
4755 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
4756 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
4757 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
4759 /* Controls for GPIO pins, assuming they are configured as outputs */
4760 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
4761 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
4762 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
4763 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
4765 /* Switches to allow the digital IO pins to be enabled. The datasheet
4766 * is ambigious as to which NID is which; testing on laptops which
4767 * make this output available should provide clarification.
4769 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
4770 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
4772 /* A switch allowing EAPD to be enabled. Some laptops seem to use
4773 * this output to turn on an external amplifier.
4775 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
4776 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
4780 static struct hda_verb alc260_test_init_verbs[] = {
4781 /* Enable all GPIOs as outputs with an initial value of 0 */
4782 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
4783 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4784 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
4786 /* Enable retasking pins as output, initially without power amp */
4787 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4788 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4789 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4790 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4791 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4792 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4794 /* Disable digital (SPDIF) pins initially, but users can enable
4795 * them via a mixer switch. In the case of SPDIF-out, this initverb
4796 * payload also sets the generation to 0, output to be in "consumer"
4797 * PCM format, copyright asserted, no pre-emphasis and no validity
4800 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4801 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4803 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
4804 * OUT1 sum bus when acting as an output.
4806 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4807 {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
4808 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4809 {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
4811 /* Start with output sum widgets muted and their output gains at min */
4812 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4813 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4814 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4815 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4816 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4817 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4818 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4819 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4820 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4822 /* Unmute retasking pin widget output buffers since the default
4823 * state appears to be output. As the pin mode is changed by the
4824 * user the pin mode control will take care of enabling the pin's
4825 * input/output buffers as needed.
4827 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4828 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4829 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4830 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4831 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4832 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4833 /* Also unmute the mono-out pin widget */
4834 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4836 /* Mute capture amp left and right */
4837 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4838 /* Set ADC connection select to match default mixer setting (mic1
4841 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4843 /* Do the same for the second ADC: mute capture input amp and
4844 * set ADC connection to mic1 pin
4846 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4847 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4849 /* Mute all inputs to mixer widget (even unconnected ones) */
4850 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4851 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4852 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4853 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4854 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4855 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4856 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4857 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4863 #define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback
4864 #define alc260_pcm_analog_capture alc880_pcm_analog_capture
4866 #define alc260_pcm_digital_playback alc880_pcm_digital_playback
4867 #define alc260_pcm_digital_capture alc880_pcm_digital_capture
4870 * for BIOS auto-configuration
4873 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
4877 unsigned long vol_val, sw_val;
4881 if (nid >= 0x0f && nid < 0x11) {
4882 nid_vol = nid - 0x7;
4883 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4884 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4885 } else if (nid == 0x11) {
4886 nid_vol = nid - 0x7;
4887 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
4888 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
4889 } else if (nid >= 0x12 && nid <= 0x15) {
4891 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4892 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4896 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
4897 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
4900 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
4901 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
4907 /* add playback controls from the parsed DAC table */
4908 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
4909 const struct auto_pin_cfg *cfg)
4914 spec->multiout.num_dacs = 1;
4915 spec->multiout.dac_nids = spec->private_dac_nids;
4916 spec->multiout.dac_nids[0] = 0x02;
4918 nid = cfg->line_out_pins[0];
4920 err = alc260_add_playback_controls(spec, nid, "Front");
4925 nid = cfg->speaker_pins[0];
4927 err = alc260_add_playback_controls(spec, nid, "Speaker");
4932 nid = cfg->hp_pins[0];
4934 err = alc260_add_playback_controls(spec, nid, "Headphone");
4941 /* create playback/capture controls for input pins */
4942 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
4943 const struct auto_pin_cfg *cfg)
4945 struct hda_input_mux *imux = &spec->private_imux;
4948 for (i = 0; i < AUTO_PIN_LAST; i++) {
4949 if (cfg->input_pins[i] >= 0x12) {
4950 idx = cfg->input_pins[i] - 0x12;
4951 err = new_analog_input(spec, cfg->input_pins[i],
4952 auto_pin_cfg_labels[i], idx,
4956 imux->items[imux->num_items].label =
4957 auto_pin_cfg_labels[i];
4958 imux->items[imux->num_items].index = idx;
4961 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
4962 idx = cfg->input_pins[i] - 0x09;
4963 err = new_analog_input(spec, cfg->input_pins[i],
4964 auto_pin_cfg_labels[i], idx,
4968 imux->items[imux->num_items].label =
4969 auto_pin_cfg_labels[i];
4970 imux->items[imux->num_items].index = idx;
4977 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
4978 hda_nid_t nid, int pin_type,
4981 alc_set_pin_output(codec, nid, pin_type);
4982 /* need the manual connection? */
4984 int idx = nid - 0x12;
4985 snd_hda_codec_write(codec, idx + 0x0b, 0,
4986 AC_VERB_SET_CONNECT_SEL, sel_idx);
4990 static void alc260_auto_init_multi_out(struct hda_codec *codec)
4992 struct alc_spec *spec = codec->spec;
4995 alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
4996 nid = spec->autocfg.line_out_pins[0];
4998 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4999 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5002 nid = spec->autocfg.speaker_pins[0];
5004 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5006 nid = spec->autocfg.hp_pins[0];
5008 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5011 #define ALC260_PIN_CD_NID 0x16
5012 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5014 struct alc_spec *spec = codec->spec;
5017 for (i = 0; i < AUTO_PIN_LAST; i++) {
5018 hda_nid_t nid = spec->autocfg.input_pins[i];
5020 snd_hda_codec_write(codec, nid, 0,
5021 AC_VERB_SET_PIN_WIDGET_CONTROL,
5022 i <= AUTO_PIN_FRONT_MIC ?
5023 PIN_VREF80 : PIN_IN);
5024 if (nid != ALC260_PIN_CD_NID)
5025 snd_hda_codec_write(codec, nid, 0,
5026 AC_VERB_SET_AMP_GAIN_MUTE,
5033 * generic initialization of ADC, input mixers and output mixers
5035 static struct hda_verb alc260_volume_init_verbs[] = {
5037 * Unmute ADC0-1 and set the default input to mic-in
5039 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5040 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5041 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5042 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5044 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5046 * Note: PASD motherboards uses the Line In 2 as the input for
5047 * front panel mic (mic 2)
5049 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5050 /* mute analog inputs */
5051 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5052 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5053 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5054 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5055 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5058 * Set up output mixers (0x08 - 0x0a)
5060 /* set vol=0 to output mixers */
5061 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5062 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5063 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5064 /* set up input amps for analog loopback */
5065 /* Amp Indices: DAC = 0, mixer = 1 */
5066 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5067 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5068 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5069 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5070 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5071 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5076 static int alc260_parse_auto_config(struct hda_codec *codec)
5078 struct alc_spec *spec = codec->spec;
5081 static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5083 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5087 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5090 if (!spec->kctl_alloc)
5091 return 0; /* can't find valid BIOS pin config */
5092 err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5096 spec->multiout.max_channels = 2;
5098 if (spec->autocfg.dig_out_pin)
5099 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5100 if (spec->kctl_alloc)
5101 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5103 spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
5105 spec->num_mux_defs = 1;
5106 spec->input_mux = &spec->private_imux;
5108 /* check whether NID 0x04 is valid */
5109 wcap = get_wcaps(codec, 0x04);
5110 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5111 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5112 spec->adc_nids = alc260_adc_nids_alt;
5113 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5114 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
5116 spec->adc_nids = alc260_adc_nids;
5117 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5118 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
5125 /* additional initialization for auto-configuration model */
5126 static void alc260_auto_init(struct hda_codec *codec)
5128 struct alc_spec *spec = codec->spec;
5129 alc260_auto_init_multi_out(codec);
5130 alc260_auto_init_analog_input(codec);
5131 if (spec->unsol_event)
5132 alc_sku_automute(codec);
5135 #ifdef CONFIG_SND_HDA_POWER_SAVE
5136 static struct hda_amp_list alc260_loopbacks[] = {
5137 { 0x07, HDA_INPUT, 0 },
5138 { 0x07, HDA_INPUT, 1 },
5139 { 0x07, HDA_INPUT, 2 },
5140 { 0x07, HDA_INPUT, 3 },
5141 { 0x07, HDA_INPUT, 4 },
5147 * ALC260 configurations
5149 static const char *alc260_models[ALC260_MODEL_LAST] = {
5150 [ALC260_BASIC] = "basic",
5152 [ALC260_HP_3013] = "hp-3013",
5153 [ALC260_FUJITSU_S702X] = "fujitsu",
5154 [ALC260_ACER] = "acer",
5155 [ALC260_WILL] = "will",
5156 [ALC260_REPLACER_672V] = "replacer",
5157 #ifdef CONFIG_SND_DEBUG
5158 [ALC260_TEST] = "test",
5160 [ALC260_AUTO] = "auto",
5163 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5164 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5165 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5166 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5167 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5168 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5169 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP),
5170 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_3013),
5171 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5172 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5173 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5174 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5175 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5176 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5177 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5178 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5179 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5180 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5181 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5185 static struct alc_config_preset alc260_presets[] = {
5187 .mixers = { alc260_base_output_mixer,
5189 alc260_pc_beep_mixer,
5190 alc260_capture_mixer },
5191 .init_verbs = { alc260_init_verbs },
5192 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5193 .dac_nids = alc260_dac_nids,
5194 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5195 .adc_nids = alc260_adc_nids,
5196 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5197 .channel_mode = alc260_modes,
5198 .input_mux = &alc260_capture_source,
5201 .mixers = { alc260_hp_output_mixer,
5203 alc260_capture_alt_mixer },
5204 .init_verbs = { alc260_init_verbs,
5205 alc260_hp_unsol_verbs },
5206 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5207 .dac_nids = alc260_dac_nids,
5208 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5209 .adc_nids = alc260_hp_adc_nids,
5210 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5211 .channel_mode = alc260_modes,
5212 .input_mux = &alc260_capture_source,
5213 .unsol_event = alc260_hp_unsol_event,
5214 .init_hook = alc260_hp_automute,
5216 [ALC260_HP_3013] = {
5217 .mixers = { alc260_hp_3013_mixer,
5219 alc260_capture_alt_mixer },
5220 .init_verbs = { alc260_hp_3013_init_verbs,
5221 alc260_hp_3013_unsol_verbs },
5222 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5223 .dac_nids = alc260_dac_nids,
5224 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5225 .adc_nids = alc260_hp_adc_nids,
5226 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5227 .channel_mode = alc260_modes,
5228 .input_mux = &alc260_capture_source,
5229 .unsol_event = alc260_hp_3013_unsol_event,
5230 .init_hook = alc260_hp_3013_automute,
5232 [ALC260_FUJITSU_S702X] = {
5233 .mixers = { alc260_fujitsu_mixer,
5234 alc260_capture_mixer },
5235 .init_verbs = { alc260_fujitsu_init_verbs },
5236 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5237 .dac_nids = alc260_dac_nids,
5238 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5239 .adc_nids = alc260_dual_adc_nids,
5240 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5241 .channel_mode = alc260_modes,
5242 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5243 .input_mux = alc260_fujitsu_capture_sources,
5246 .mixers = { alc260_acer_mixer,
5247 alc260_capture_mixer },
5248 .init_verbs = { alc260_acer_init_verbs },
5249 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5250 .dac_nids = alc260_dac_nids,
5251 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5252 .adc_nids = alc260_dual_adc_nids,
5253 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5254 .channel_mode = alc260_modes,
5255 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5256 .input_mux = alc260_acer_capture_sources,
5259 .mixers = { alc260_will_mixer,
5260 alc260_capture_mixer },
5261 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5262 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5263 .dac_nids = alc260_dac_nids,
5264 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5265 .adc_nids = alc260_adc_nids,
5266 .dig_out_nid = ALC260_DIGOUT_NID,
5267 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5268 .channel_mode = alc260_modes,
5269 .input_mux = &alc260_capture_source,
5271 [ALC260_REPLACER_672V] = {
5272 .mixers = { alc260_replacer_672v_mixer,
5273 alc260_capture_mixer },
5274 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5275 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5276 .dac_nids = alc260_dac_nids,
5277 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5278 .adc_nids = alc260_adc_nids,
5279 .dig_out_nid = ALC260_DIGOUT_NID,
5280 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5281 .channel_mode = alc260_modes,
5282 .input_mux = &alc260_capture_source,
5283 .unsol_event = alc260_replacer_672v_unsol_event,
5284 .init_hook = alc260_replacer_672v_automute,
5286 #ifdef CONFIG_SND_DEBUG
5288 .mixers = { alc260_test_mixer,
5289 alc260_capture_mixer },
5290 .init_verbs = { alc260_test_init_verbs },
5291 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5292 .dac_nids = alc260_test_dac_nids,
5293 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5294 .adc_nids = alc260_test_adc_nids,
5295 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5296 .channel_mode = alc260_modes,
5297 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5298 .input_mux = alc260_test_capture_sources,
5303 static int patch_alc260(struct hda_codec *codec)
5305 struct alc_spec *spec;
5306 int err, board_config;
5308 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5314 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5317 if (board_config < 0) {
5318 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5319 "trying auto-probe from BIOS...\n");
5320 board_config = ALC260_AUTO;
5323 if (board_config == ALC260_AUTO) {
5324 /* automatic parse from the BIOS config */
5325 err = alc260_parse_auto_config(codec);
5331 "hda_codec: Cannot set up configuration "
5332 "from BIOS. Using base mode...\n");
5333 board_config = ALC260_BASIC;
5337 if (board_config != ALC260_AUTO)
5338 setup_preset(spec, &alc260_presets[board_config]);
5340 spec->stream_name_analog = "ALC260 Analog";
5341 spec->stream_analog_playback = &alc260_pcm_analog_playback;
5342 spec->stream_analog_capture = &alc260_pcm_analog_capture;
5344 spec->stream_name_digital = "ALC260 Digital";
5345 spec->stream_digital_playback = &alc260_pcm_digital_playback;
5346 spec->stream_digital_capture = &alc260_pcm_digital_capture;
5348 spec->vmaster_nid = 0x08;
5350 codec->patch_ops = alc_patch_ops;
5351 if (board_config == ALC260_AUTO)
5352 spec->init_hook = alc260_auto_init;
5353 #ifdef CONFIG_SND_HDA_POWER_SAVE
5354 if (!spec->loopback.amplist)
5355 spec->loopback.amplist = alc260_loopbacks;
5365 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5366 * configuration. Each pin widget can choose any input DACs and a mixer.
5367 * Each ADC is connected from a mixer of all inputs. This makes possible
5368 * 6-channel independent captures.
5370 * In addition, an independent DAC for the multi-playback (not used in this
5373 #define ALC882_DIGOUT_NID 0x06
5374 #define ALC882_DIGIN_NID 0x0a
5376 static struct hda_channel_mode alc882_ch_modes[1] = {
5380 static hda_nid_t alc882_dac_nids[4] = {
5381 /* front, rear, clfe, rear_surr */
5382 0x02, 0x03, 0x04, 0x05
5385 /* identical with ALC880 */
5386 #define alc882_adc_nids alc880_adc_nids
5387 #define alc882_adc_nids_alt alc880_adc_nids_alt
5389 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5390 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5393 /* FIXME: should be a matrix-type input source selection */
5395 static struct hda_input_mux alc882_capture_source = {
5399 { "Front Mic", 0x1 },
5404 #define alc882_mux_enum_info alc_mux_enum_info
5405 #define alc882_mux_enum_get alc_mux_enum_get
5407 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
5408 struct snd_ctl_elem_value *ucontrol)
5410 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5411 struct alc_spec *spec = codec->spec;
5412 const struct hda_input_mux *imux = spec->input_mux;
5413 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5414 hda_nid_t nid = spec->capsrc_nids ?
5415 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
5416 unsigned int *cur_val = &spec->cur_mux[adc_idx];
5417 unsigned int i, idx;
5419 idx = ucontrol->value.enumerated.item[0];
5420 if (idx >= imux->num_items)
5421 idx = imux->num_items - 1;
5422 if (*cur_val == idx)
5424 for (i = 0; i < imux->num_items; i++) {
5425 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
5426 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
5427 imux->items[i].index,
5437 static struct hda_verb alc882_3ST_ch2_init[] = {
5438 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5439 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5440 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5441 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5448 static struct hda_verb alc882_3ST_ch6_init[] = {
5449 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5450 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5451 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5452 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5453 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5454 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5458 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5459 { 2, alc882_3ST_ch2_init },
5460 { 6, alc882_3ST_ch6_init },
5466 static struct hda_verb alc882_sixstack_ch6_init[] = {
5467 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5468 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5469 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5470 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5477 static struct hda_verb alc882_sixstack_ch8_init[] = {
5478 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5479 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5480 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5481 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5485 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5486 { 6, alc882_sixstack_ch6_init },
5487 { 8, alc882_sixstack_ch8_init },
5491 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
5497 static struct hda_verb alc885_mbp_ch2_init[] = {
5498 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5499 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5500 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5507 static struct hda_verb alc885_mbp_ch6_init[] = {
5508 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5509 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5510 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5511 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5512 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5516 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
5517 { 2, alc885_mbp_ch2_init },
5518 { 6, alc885_mbp_ch6_init },
5522 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5523 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5525 static struct snd_kcontrol_new alc882_base_mixer[] = {
5526 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5527 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5528 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5529 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5530 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5531 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5532 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5533 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5534 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5535 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5536 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5537 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5538 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5539 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5540 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5541 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5542 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5543 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5544 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5545 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5546 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5547 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5548 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5552 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
5553 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5554 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
5555 HDA_CODEC_MUTE ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
5556 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
5557 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5558 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5559 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
5560 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
5561 HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
5562 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
5565 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
5566 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5567 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5568 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5569 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5570 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5571 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5572 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5573 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5574 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5575 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5576 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5580 static struct snd_kcontrol_new alc882_targa_mixer[] = {
5581 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5582 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5583 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5584 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5585 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5586 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5587 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5588 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5589 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5590 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5591 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5592 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5593 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5597 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
5598 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
5600 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
5601 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5602 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5603 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5604 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5605 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5606 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5607 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5608 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5609 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
5610 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
5611 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5612 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5613 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5617 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
5618 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5619 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5620 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5621 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5622 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5623 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5624 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5625 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5626 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5627 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5628 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5629 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5633 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
5635 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5636 .name = "Channel Mode",
5637 .info = alc_ch_mode_info,
5638 .get = alc_ch_mode_get,
5639 .put = alc_ch_mode_put,
5644 static struct hda_verb alc882_init_verbs[] = {
5645 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5646 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5647 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5648 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5650 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5651 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5652 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5654 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5655 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5656 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5658 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5659 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5660 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5662 /* Front Pin: output 0 (0x0c) */
5663 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5664 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5665 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5666 /* Rear Pin: output 1 (0x0d) */
5667 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5668 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5669 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5670 /* CLFE Pin: output 2 (0x0e) */
5671 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5672 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5673 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5674 /* Side Pin: output 3 (0x0f) */
5675 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5676 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5677 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5678 /* Mic (rear) pin: input vref at 80% */
5679 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5680 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5681 /* Front Mic pin: input vref at 80% */
5682 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5683 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5684 /* Line In pin: input */
5685 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5686 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5687 /* Line-2 In: Headphone output (output 0 - 0x0c) */
5688 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5689 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5690 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5691 /* CD pin widget for input */
5692 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5694 /* FIXME: use matrix-type input source selection */
5695 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5696 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5697 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5698 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5699 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5700 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5702 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5703 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5704 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5705 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5707 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5708 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5709 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5710 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5711 /* ADC1: mute amp left and right */
5712 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5713 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5714 /* ADC2: mute amp left and right */
5715 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5716 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5717 /* ADC3: mute amp left and right */
5718 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5719 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5724 static struct hda_verb alc882_eapd_verbs[] = {
5725 /* change to EAPD mode */
5726 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5727 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
5732 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
5733 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5734 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5735 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
5736 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
5737 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
5738 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
5739 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
5743 static struct hda_verb alc882_macpro_init_verbs[] = {
5744 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5745 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5746 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5747 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5748 /* Front Pin: output 0 (0x0c) */
5749 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5750 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5751 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5752 /* Front Mic pin: input vref at 80% */
5753 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5754 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5755 /* Speaker: output */
5756 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5757 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5758 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
5759 /* Headphone output (output 0 - 0x0c) */
5760 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5761 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5762 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5764 /* FIXME: use matrix-type input source selection */
5765 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5766 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5767 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5768 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5769 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5770 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5772 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5773 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5774 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5775 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5777 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5778 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5779 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5780 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5781 /* ADC1: mute amp left and right */
5782 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5783 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5784 /* ADC2: mute amp left and right */
5785 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5786 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5787 /* ADC3: mute amp left and right */
5788 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5789 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5794 /* Macbook Pro rev3 */
5795 static struct hda_verb alc885_mbp3_init_verbs[] = {
5796 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5797 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5798 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5799 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5801 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5802 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5803 {0x0d, 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 /* HP Pin: output 0 (0x0d) */
5809 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
5810 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5811 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5812 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5813 /* Mic (rear) pin: input vref at 80% */
5814 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5815 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5816 /* Front Mic pin: input vref at 80% */
5817 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5818 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5819 /* Line In pin: use output 1 when in LineOut mode */
5820 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5821 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5822 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
5824 /* FIXME: use matrix-type input source selection */
5825 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5826 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5827 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5828 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5829 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5830 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5832 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5833 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5834 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5835 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5837 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5838 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5839 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5840 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5841 /* ADC1: mute amp left and right */
5842 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5843 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5844 /* ADC2: mute amp left and right */
5845 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5846 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5847 /* ADC3: mute amp left and right */
5848 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5849 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5854 /* iMac 24 mixer. */
5855 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
5856 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5857 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
5861 /* iMac 24 init verbs. */
5862 static struct hda_verb alc885_imac24_init_verbs[] = {
5863 /* Internal speakers: output 0 (0x0c) */
5864 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5865 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5866 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5867 /* Internal speakers: output 0 (0x0c) */
5868 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5869 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5870 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
5871 /* Headphone: output 0 (0x0c) */
5872 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5873 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5874 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5875 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5876 /* Front Mic: input vref at 80% */
5877 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5878 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5882 /* Toggle speaker-output according to the hp-jack state */
5883 static void alc885_imac24_automute(struct hda_codec *codec)
5885 unsigned int present;
5887 present = snd_hda_codec_read(codec, 0x14, 0,
5888 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5889 snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
5890 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5891 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
5892 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5895 /* Processes unsolicited events. */
5896 static void alc885_imac24_unsol_event(struct hda_codec *codec,
5899 /* Headphone insertion or removal. */
5900 if ((res >> 26) == ALC880_HP_EVENT)
5901 alc885_imac24_automute(codec);
5904 static void alc885_mbp3_automute(struct hda_codec *codec)
5906 unsigned int present;
5908 present = snd_hda_codec_read(codec, 0x15, 0,
5909 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5910 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
5911 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5912 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
5913 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
5916 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
5919 /* Headphone insertion or removal. */
5920 if ((res >> 26) == ALC880_HP_EVENT)
5921 alc885_mbp3_automute(codec);
5925 static struct hda_verb alc882_targa_verbs[] = {
5926 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5927 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5929 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5930 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5932 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5933 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5934 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5936 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5937 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5938 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
5939 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
5943 /* toggle speaker-output according to the hp-jack state */
5944 static void alc882_targa_automute(struct hda_codec *codec)
5946 unsigned int present;
5948 present = snd_hda_codec_read(codec, 0x14, 0,
5949 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5950 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
5951 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5952 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
5956 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
5958 /* Looks like the unsol event is incompatible with the standard
5959 * definition. 4bit tag is placed at 26 bit!
5961 if (((res >> 26) == ALC880_HP_EVENT)) {
5962 alc882_targa_automute(codec);
5966 static struct hda_verb alc882_asus_a7j_verbs[] = {
5967 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5968 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5970 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5971 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5972 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5974 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5975 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5976 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5978 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5979 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5980 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5984 static struct hda_verb alc882_asus_a7m_verbs[] = {
5985 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5986 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5988 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5989 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5990 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5992 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5993 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5994 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5996 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5997 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5998 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6002 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6004 unsigned int gpiostate, gpiomask, gpiodir;
6006 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6007 AC_VERB_GET_GPIO_DATA, 0);
6010 gpiostate |= (1 << pin);
6012 gpiostate &= ~(1 << pin);
6014 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6015 AC_VERB_GET_GPIO_MASK, 0);
6016 gpiomask |= (1 << pin);
6018 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6019 AC_VERB_GET_GPIO_DIRECTION, 0);
6020 gpiodir |= (1 << pin);
6023 snd_hda_codec_write(codec, codec->afg, 0,
6024 AC_VERB_SET_GPIO_MASK, gpiomask);
6025 snd_hda_codec_write(codec, codec->afg, 0,
6026 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6030 snd_hda_codec_write(codec, codec->afg, 0,
6031 AC_VERB_SET_GPIO_DATA, gpiostate);
6034 /* set up GPIO at initialization */
6035 static void alc885_macpro_init_hook(struct hda_codec *codec)
6037 alc882_gpio_mute(codec, 0, 0);
6038 alc882_gpio_mute(codec, 1, 0);
6041 /* set up GPIO and update auto-muting at initialization */
6042 static void alc885_imac24_init_hook(struct hda_codec *codec)
6044 alc885_macpro_init_hook(codec);
6045 alc885_imac24_automute(codec);
6049 * generic initialization of ADC, input mixers and output mixers
6051 static struct hda_verb alc882_auto_init_verbs[] = {
6053 * Unmute ADC0-2 and set the default input to mic-in
6055 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6056 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6057 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6058 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6059 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6060 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6062 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6064 * Note: PASD motherboards uses the Line In 2 as the input for
6065 * front panel mic (mic 2)
6067 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6068 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6069 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6070 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6071 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6072 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6075 * Set up output mixers (0x0c - 0x0f)
6077 /* set vol=0 to output mixers */
6078 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6079 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6080 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6081 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6082 /* set up input amps for analog loopback */
6083 /* Amp Indices: DAC = 0, mixer = 1 */
6084 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6085 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6086 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6087 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6088 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6089 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6090 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6091 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6092 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6093 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6095 /* FIXME: use matrix-type input source selection */
6096 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6097 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6098 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6099 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6100 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6101 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6103 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6104 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6105 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6106 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6108 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6109 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6110 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6111 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6116 /* capture mixer elements */
6117 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
6118 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6119 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6120 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6121 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6123 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6124 /* The multiple "Capture Source" controls confuse alsamixer
6125 * So call somewhat different..
6127 /* .name = "Capture Source", */
6128 .name = "Input Source",
6130 .info = alc882_mux_enum_info,
6131 .get = alc882_mux_enum_get,
6132 .put = alc882_mux_enum_put,
6137 static struct snd_kcontrol_new alc882_capture_mixer[] = {
6138 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
6139 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
6140 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
6141 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
6142 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
6143 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
6145 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6146 /* The multiple "Capture Source" controls confuse alsamixer
6147 * So call somewhat different..
6149 /* .name = "Capture Source", */
6150 .name = "Input Source",
6152 .info = alc882_mux_enum_info,
6153 .get = alc882_mux_enum_get,
6154 .put = alc882_mux_enum_put,
6159 #ifdef CONFIG_SND_HDA_POWER_SAVE
6160 #define alc882_loopbacks alc880_loopbacks
6163 /* pcm configuration: identiacal with ALC880 */
6164 #define alc882_pcm_analog_playback alc880_pcm_analog_playback
6165 #define alc882_pcm_analog_capture alc880_pcm_analog_capture
6166 #define alc882_pcm_digital_playback alc880_pcm_digital_playback
6167 #define alc882_pcm_digital_capture alc880_pcm_digital_capture
6170 * configuration and preset
6172 static const char *alc882_models[ALC882_MODEL_LAST] = {
6173 [ALC882_3ST_DIG] = "3stack-dig",
6174 [ALC882_6ST_DIG] = "6stack-dig",
6175 [ALC882_ARIMA] = "arima",
6176 [ALC882_W2JC] = "w2jc",
6177 [ALC882_TARGA] = "targa",
6178 [ALC882_ASUS_A7J] = "asus-a7j",
6179 [ALC882_ASUS_A7M] = "asus-a7m",
6180 [ALC885_MACPRO] = "macpro",
6181 [ALC885_MBP3] = "mbp3",
6182 [ALC885_IMAC24] = "imac24",
6183 [ALC882_AUTO] = "auto",
6186 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6187 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6188 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6189 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6190 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6191 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6192 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6193 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6194 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6195 SND_PCI_QUIRK(0x106b, 0x00a0, "Apple iMac 24''", ALC885_IMAC24),
6196 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6197 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */
6198 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6199 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6203 static struct alc_config_preset alc882_presets[] = {
6204 [ALC882_3ST_DIG] = {
6205 .mixers = { alc882_base_mixer },
6206 .init_verbs = { alc882_init_verbs },
6207 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6208 .dac_nids = alc882_dac_nids,
6209 .dig_out_nid = ALC882_DIGOUT_NID,
6210 .dig_in_nid = ALC882_DIGIN_NID,
6211 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6212 .channel_mode = alc882_ch_modes,
6214 .input_mux = &alc882_capture_source,
6216 [ALC882_6ST_DIG] = {
6217 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6218 .init_verbs = { alc882_init_verbs },
6219 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6220 .dac_nids = alc882_dac_nids,
6221 .dig_out_nid = ALC882_DIGOUT_NID,
6222 .dig_in_nid = ALC882_DIGIN_NID,
6223 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6224 .channel_mode = alc882_sixstack_modes,
6225 .input_mux = &alc882_capture_source,
6228 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6229 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6230 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6231 .dac_nids = alc882_dac_nids,
6232 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6233 .channel_mode = alc882_sixstack_modes,
6234 .input_mux = &alc882_capture_source,
6237 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6238 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6239 alc880_gpio1_init_verbs },
6240 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6241 .dac_nids = alc882_dac_nids,
6242 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6243 .channel_mode = alc880_threestack_modes,
6245 .input_mux = &alc882_capture_source,
6246 .dig_out_nid = ALC882_DIGOUT_NID,
6249 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6250 .init_verbs = { alc885_mbp3_init_verbs,
6251 alc880_gpio1_init_verbs },
6252 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6253 .dac_nids = alc882_dac_nids,
6254 .channel_mode = alc885_mbp_6ch_modes,
6255 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6256 .input_mux = &alc882_capture_source,
6257 .dig_out_nid = ALC882_DIGOUT_NID,
6258 .dig_in_nid = ALC882_DIGIN_NID,
6259 .unsol_event = alc885_mbp3_unsol_event,
6260 .init_hook = alc885_mbp3_automute,
6263 .mixers = { alc882_macpro_mixer },
6264 .init_verbs = { alc882_macpro_init_verbs },
6265 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6266 .dac_nids = alc882_dac_nids,
6267 .dig_out_nid = ALC882_DIGOUT_NID,
6268 .dig_in_nid = ALC882_DIGIN_NID,
6269 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6270 .channel_mode = alc882_ch_modes,
6271 .input_mux = &alc882_capture_source,
6272 .init_hook = alc885_macpro_init_hook,
6275 .mixers = { alc885_imac24_mixer },
6276 .init_verbs = { alc885_imac24_init_verbs },
6277 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6278 .dac_nids = alc882_dac_nids,
6279 .dig_out_nid = ALC882_DIGOUT_NID,
6280 .dig_in_nid = ALC882_DIGIN_NID,
6281 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6282 .channel_mode = alc882_ch_modes,
6283 .input_mux = &alc882_capture_source,
6284 .unsol_event = alc885_imac24_unsol_event,
6285 .init_hook = alc885_imac24_init_hook,
6288 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
6289 alc882_capture_mixer },
6290 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6291 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6292 .dac_nids = alc882_dac_nids,
6293 .dig_out_nid = ALC882_DIGOUT_NID,
6294 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6295 .adc_nids = alc882_adc_nids,
6296 .capsrc_nids = alc882_capsrc_nids,
6297 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6298 .channel_mode = alc882_3ST_6ch_modes,
6300 .input_mux = &alc882_capture_source,
6301 .unsol_event = alc882_targa_unsol_event,
6302 .init_hook = alc882_targa_automute,
6304 [ALC882_ASUS_A7J] = {
6305 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
6306 alc882_capture_mixer },
6307 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6308 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6309 .dac_nids = alc882_dac_nids,
6310 .dig_out_nid = ALC882_DIGOUT_NID,
6311 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6312 .adc_nids = alc882_adc_nids,
6313 .capsrc_nids = alc882_capsrc_nids,
6314 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6315 .channel_mode = alc882_3ST_6ch_modes,
6317 .input_mux = &alc882_capture_source,
6319 [ALC882_ASUS_A7M] = {
6320 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6321 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6322 alc880_gpio1_init_verbs,
6323 alc882_asus_a7m_verbs },
6324 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6325 .dac_nids = alc882_dac_nids,
6326 .dig_out_nid = ALC882_DIGOUT_NID,
6327 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6328 .channel_mode = alc880_threestack_modes,
6330 .input_mux = &alc882_capture_source,
6339 PINFIX_ABIT_AW9D_MAX
6342 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6343 { 0x15, 0x01080104 }, /* side */
6344 { 0x16, 0x01011012 }, /* rear */
6345 { 0x17, 0x01016011 }, /* clfe */
6349 static const struct alc_pincfg *alc882_pin_fixes[] = {
6350 [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6353 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6354 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6359 * BIOS auto configuration
6361 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6362 hda_nid_t nid, int pin_type,
6366 struct alc_spec *spec = codec->spec;
6369 alc_set_pin_output(codec, nid, pin_type);
6370 if (spec->multiout.dac_nids[dac_idx] == 0x25)
6373 idx = spec->multiout.dac_nids[dac_idx] - 2;
6374 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6378 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6380 struct alc_spec *spec = codec->spec;
6383 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6384 for (i = 0; i <= HDA_SIDE; i++) {
6385 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6386 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6388 alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6393 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6395 struct alc_spec *spec = codec->spec;
6398 pin = spec->autocfg.hp_pins[0];
6399 if (pin) /* connect to front */
6401 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6402 pin = spec->autocfg.speaker_pins[0];
6404 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6407 #define alc882_is_input_pin(nid) alc880_is_input_pin(nid)
6408 #define ALC882_PIN_CD_NID ALC880_PIN_CD_NID
6410 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6412 struct alc_spec *spec = codec->spec;
6415 for (i = 0; i < AUTO_PIN_LAST; i++) {
6416 hda_nid_t nid = spec->autocfg.input_pins[i];
6421 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
6422 unsigned int pincap;
6423 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
6424 if ((pincap >> AC_PINCAP_VREF_SHIFT) &
6428 snd_hda_codec_write(codec, nid, 0,
6429 AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
6430 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
6431 snd_hda_codec_write(codec, nid, 0,
6432 AC_VERB_SET_AMP_GAIN_MUTE,
6437 /* add mic boosts if needed */
6438 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6440 struct alc_spec *spec = codec->spec;
6444 nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6445 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6446 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6448 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6452 nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6453 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6454 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6456 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6463 /* almost identical with ALC880 parser... */
6464 static int alc882_parse_auto_config(struct hda_codec *codec)
6466 struct alc_spec *spec = codec->spec;
6467 int err = alc880_parse_auto_config(codec);
6472 return 0; /* no config found */
6474 err = alc_auto_add_mic_boost(codec);
6478 /* hack - override the init verbs */
6479 spec->init_verbs[0] = alc882_auto_init_verbs;
6481 return 1; /* config found */
6484 /* additional initialization for auto-configuration model */
6485 static void alc882_auto_init(struct hda_codec *codec)
6487 struct alc_spec *spec = codec->spec;
6488 alc882_auto_init_multi_out(codec);
6489 alc882_auto_init_hp_out(codec);
6490 alc882_auto_init_analog_input(codec);
6491 if (spec->unsol_event)
6492 alc_sku_automute(codec);
6495 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
6497 static int patch_alc882(struct hda_codec *codec)
6499 struct alc_spec *spec;
6500 int err, board_config;
6502 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6508 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6512 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6513 /* Pick up systems that don't supply PCI SSID */
6514 switch (codec->subsystem_id) {
6515 case 0x106b0c00: /* Mac Pro */
6516 board_config = ALC885_MACPRO;
6518 case 0x106b1000: /* iMac 24 */
6519 board_config = ALC885_IMAC24;
6521 case 0x106b00a1: /* Macbook */
6522 case 0x106b2c00: /* Macbook Pro rev3 */
6523 board_config = ALC885_MBP3;
6526 /* ALC889A is handled better as ALC888-compatible */
6527 if (codec->revision_id == 0x100103) {
6529 return patch_alc883(codec);
6531 printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6532 "trying auto-probe from BIOS...\n");
6533 board_config = ALC882_AUTO;
6537 alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6539 if (board_config == ALC882_AUTO) {
6540 /* automatic parse from the BIOS config */
6541 err = alc882_parse_auto_config(codec);
6547 "hda_codec: Cannot set up configuration "
6548 "from BIOS. Using base mode...\n");
6549 board_config = ALC882_3ST_DIG;
6553 if (board_config != ALC882_AUTO)
6554 setup_preset(spec, &alc882_presets[board_config]);
6556 if (codec->vendor_id == 0x10ec0885) {
6557 spec->stream_name_analog = "ALC885 Analog";
6558 spec->stream_name_digital = "ALC885 Digital";
6560 spec->stream_name_analog = "ALC882 Analog";
6561 spec->stream_name_digital = "ALC882 Digital";
6564 spec->stream_analog_playback = &alc882_pcm_analog_playback;
6565 spec->stream_analog_capture = &alc882_pcm_analog_capture;
6566 /* FIXME: setup DAC5 */
6567 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6568 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6570 spec->stream_digital_playback = &alc882_pcm_digital_playback;
6571 spec->stream_digital_capture = &alc882_pcm_digital_capture;
6573 if (!spec->adc_nids && spec->input_mux) {
6574 /* check whether NID 0x07 is valid */
6575 unsigned int wcap = get_wcaps(codec, 0x07);
6577 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6578 if (wcap != AC_WID_AUD_IN) {
6579 spec->adc_nids = alc882_adc_nids_alt;
6580 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6581 spec->capsrc_nids = alc882_capsrc_nids_alt;
6582 spec->mixers[spec->num_mixers] =
6583 alc882_capture_alt_mixer;
6586 spec->adc_nids = alc882_adc_nids;
6587 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6588 spec->capsrc_nids = alc882_capsrc_nids;
6589 spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6594 spec->vmaster_nid = 0x0c;
6596 codec->patch_ops = alc_patch_ops;
6597 if (board_config == ALC882_AUTO)
6598 spec->init_hook = alc882_auto_init;
6599 #ifdef CONFIG_SND_HDA_POWER_SAVE
6600 if (!spec->loopback.amplist)
6601 spec->loopback.amplist = alc882_loopbacks;
6610 * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6611 * configuration. Each pin widget can choose any input DACs and a mixer.
6612 * Each ADC is connected from a mixer of all inputs. This makes possible
6613 * 6-channel independent captures.
6615 * In addition, an independent DAC for the multi-playback (not used in this
6618 #define ALC883_DIGOUT_NID 0x06
6619 #define ALC883_DIGIN_NID 0x0a
6621 static hda_nid_t alc883_dac_nids[4] = {
6622 /* front, rear, clfe, rear_surr */
6623 0x02, 0x03, 0x04, 0x05
6626 static hda_nid_t alc883_adc_nids[2] = {
6631 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6634 /* FIXME: should be a matrix-type input source selection */
6636 static struct hda_input_mux alc883_capture_source = {
6640 { "Front Mic", 0x1 },
6646 static struct hda_input_mux alc883_3stack_6ch_intel = {
6650 { "Front Mic", 0x0 },
6656 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6664 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6674 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6682 #define alc883_mux_enum_info alc_mux_enum_info
6683 #define alc883_mux_enum_get alc_mux_enum_get
6684 /* ALC883 has the ALC882-type input selection */
6685 #define alc883_mux_enum_put alc882_mux_enum_put
6690 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6697 static struct hda_verb alc883_3ST_ch2_init[] = {
6698 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6699 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6700 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6701 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6708 static struct hda_verb alc883_3ST_ch4_init[] = {
6709 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6710 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6711 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6712 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6713 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6720 static struct hda_verb alc883_3ST_ch6_init[] = {
6721 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6722 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6723 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6724 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6725 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6726 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6730 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
6731 { 2, alc883_3ST_ch2_init },
6732 { 4, alc883_3ST_ch4_init },
6733 { 6, alc883_3ST_ch6_init },
6739 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6740 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6741 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6742 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6743 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6750 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6751 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6752 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6753 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6754 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6755 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6762 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6763 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6764 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6765 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6766 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6767 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6768 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6772 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6773 { 2, alc883_3ST_ch2_intel_init },
6774 { 4, alc883_3ST_ch4_intel_init },
6775 { 6, alc883_3ST_ch6_intel_init },
6781 static struct hda_verb alc883_sixstack_ch6_init[] = {
6782 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6783 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6784 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6785 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6792 static struct hda_verb alc883_sixstack_ch8_init[] = {
6793 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6794 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6795 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6796 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6800 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6801 { 6, alc883_sixstack_ch6_init },
6802 { 8, alc883_sixstack_ch8_init },
6805 static struct hda_verb alc883_medion_eapd_verbs[] = {
6806 /* eanable EAPD on medion laptop */
6807 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6808 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
6812 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6813 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6816 static struct snd_kcontrol_new alc883_base_mixer[] = {
6817 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6818 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6819 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6820 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6821 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6822 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6823 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6824 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6825 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6826 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6827 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6828 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6829 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6830 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6831 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6832 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6833 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6834 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6835 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6836 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6837 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6838 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6839 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6840 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6841 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6842 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6843 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6845 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6846 /* .name = "Capture Source", */
6847 .name = "Input Source",
6849 .info = alc883_mux_enum_info,
6850 .get = alc883_mux_enum_get,
6851 .put = alc883_mux_enum_put,
6856 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
6857 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6858 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6859 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6860 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6861 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6862 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6863 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6864 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6865 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6866 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6867 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6868 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6869 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6870 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6871 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6872 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6873 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6875 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6876 /* .name = "Capture Source", */
6877 .name = "Input Source",
6879 .info = alc883_mux_enum_info,
6880 .get = alc883_mux_enum_get,
6881 .put = alc883_mux_enum_put,
6886 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
6887 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6888 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
6889 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6890 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
6891 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6892 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6893 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6894 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6895 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
6896 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6897 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6898 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6899 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6900 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6902 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6903 /* .name = "Capture Source", */
6904 .name = "Input Source",
6906 .info = alc883_mux_enum_info,
6907 .get = alc883_mux_enum_get,
6908 .put = alc883_mux_enum_put,
6913 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
6914 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6915 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
6916 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6917 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
6918 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6919 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6920 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6921 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6922 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
6923 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6924 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6925 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6926 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6927 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6929 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6930 /* .name = "Capture Source", */
6931 .name = "Input Source",
6933 .info = alc883_mux_enum_info,
6934 .get = alc883_mux_enum_get,
6935 .put = alc883_mux_enum_put,
6940 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
6941 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6942 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6943 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6944 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6945 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6946 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6947 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6948 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6949 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6950 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6951 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6952 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6953 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6954 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6955 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6956 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6957 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6958 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6959 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6961 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6962 /* .name = "Capture Source", */
6963 .name = "Input Source",
6965 .info = alc883_mux_enum_info,
6966 .get = alc883_mux_enum_get,
6967 .put = alc883_mux_enum_put,
6972 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
6973 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6974 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6975 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6976 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6977 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6978 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6979 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6980 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6981 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6982 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6983 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6984 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6985 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6986 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6987 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6988 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6989 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6990 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6991 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6992 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6993 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6994 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6995 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6996 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6997 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6999 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7000 /* .name = "Capture Source", */
7001 .name = "Input Source",
7003 .info = alc883_mux_enum_info,
7004 .get = alc883_mux_enum_get,
7005 .put = alc883_mux_enum_put,
7010 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7011 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7012 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7013 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7014 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7015 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7017 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7018 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7019 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7020 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7021 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7022 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7023 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7024 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7025 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7026 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7027 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7028 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7029 HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7030 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7031 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7032 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7033 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7034 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7035 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7036 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7038 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7039 /* .name = "Capture Source", */
7040 .name = "Input Source",
7042 .info = alc883_mux_enum_info,
7043 .get = alc883_mux_enum_get,
7044 .put = alc883_mux_enum_put,
7049 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7050 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7051 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7052 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7053 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7054 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7055 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7056 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x16, 1, 0x0, HDA_OUTPUT),
7057 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
7058 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7059 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7060 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7061 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7062 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7063 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7064 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7065 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7066 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7067 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7068 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7069 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7070 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7071 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7072 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7075 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7076 /* .name = "Capture Source", */
7077 .name = "Input Source",
7079 .info = alc883_mux_enum_info,
7080 .get = alc883_mux_enum_get,
7081 .put = alc883_mux_enum_put,
7086 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7087 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7088 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7089 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7090 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7091 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7092 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7093 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7094 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7095 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7096 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7097 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7098 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7099 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7100 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7101 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7102 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7103 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7104 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7105 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7106 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7108 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7109 /* .name = "Capture Source", */
7110 .name = "Input Source",
7112 .info = alc883_mux_enum_info,
7113 .get = alc883_mux_enum_get,
7114 .put = alc883_mux_enum_put,
7119 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7120 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7121 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7122 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7123 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7124 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7125 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7126 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7127 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7128 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7129 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7130 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7131 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7132 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7133 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7134 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7136 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7137 /* .name = "Capture Source", */
7138 .name = "Input Source",
7140 .info = alc883_mux_enum_info,
7141 .get = alc883_mux_enum_get,
7142 .put = alc883_mux_enum_put,
7147 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7148 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7149 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7150 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7151 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7152 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7153 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7154 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7155 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7156 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7157 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7159 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7160 /* .name = "Capture Source", */
7161 .name = "Input Source",
7163 .info = alc883_mux_enum_info,
7164 .get = alc883_mux_enum_get,
7165 .put = alc883_mux_enum_put,
7170 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7171 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7172 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7173 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7174 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7175 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7176 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7177 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7178 HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7179 HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7180 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7181 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7182 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7183 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7185 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7186 /* .name = "Capture Source", */
7187 .name = "Input Source",
7189 .info = alc883_mux_enum_info,
7190 .get = alc883_mux_enum_get,
7191 .put = alc883_mux_enum_put,
7196 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7197 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7198 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7199 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7200 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7201 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7202 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7203 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7204 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7205 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7206 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7207 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7208 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7209 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7211 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7212 /* .name = "Capture Source", */
7213 .name = "Input Source",
7215 .info = alc883_mux_enum_info,
7216 .get = alc883_mux_enum_get,
7217 .put = alc883_mux_enum_put,
7222 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7223 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7224 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7225 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7226 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7227 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7228 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7229 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7230 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7231 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7232 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7233 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7234 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7236 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7237 /* .name = "Capture Source", */
7238 .name = "Input Source",
7240 .info = alc883_mux_enum_info,
7241 .get = alc883_mux_enum_get,
7242 .put = alc883_mux_enum_put,
7247 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7249 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7250 .name = "Channel Mode",
7251 .info = alc_ch_mode_info,
7252 .get = alc_ch_mode_get,
7253 .put = alc_ch_mode_put,
7258 static struct hda_verb alc883_init_verbs[] = {
7259 /* ADC1: mute amp left and right */
7260 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7261 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7262 /* ADC2: mute amp left and right */
7263 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7264 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7265 /* Front mixer: unmute input/output amp left and right (volume = 0) */
7266 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7267 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7268 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7270 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7271 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7272 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7274 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7275 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7276 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7278 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7279 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7280 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7282 /* mute analog input loopbacks */
7283 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7284 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7285 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7286 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7287 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7289 /* Front Pin: output 0 (0x0c) */
7290 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7291 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7292 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7293 /* Rear Pin: output 1 (0x0d) */
7294 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7295 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7296 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7297 /* CLFE Pin: output 2 (0x0e) */
7298 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7299 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7300 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7301 /* Side Pin: output 3 (0x0f) */
7302 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7303 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7304 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7305 /* Mic (rear) pin: input vref at 80% */
7306 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7307 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7308 /* Front Mic pin: input vref at 80% */
7309 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7310 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7311 /* Line In pin: input */
7312 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7313 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7314 /* Line-2 In: Headphone output (output 0 - 0x0c) */
7315 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7316 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7317 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7318 /* CD pin widget for input */
7319 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7321 /* FIXME: use matrix-type input source selection */
7322 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7324 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7325 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7326 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7327 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7329 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7330 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7331 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7332 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7336 /* toggle speaker-output according to the hp-jack state */
7337 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7339 unsigned int present;
7341 present = snd_hda_codec_read(codec, 0x15, 0,
7342 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7343 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7344 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7345 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7346 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7349 /* auto-toggle front mic */
7351 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7353 unsigned int present;
7356 present = snd_hda_codec_read(codec, 0x18, 0,
7357 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7358 bits = present ? HDA_AMP_MUTE : 0;
7359 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7363 static void alc883_mitac_automute(struct hda_codec *codec)
7365 alc883_mitac_hp_automute(codec);
7366 /* alc883_mitac_mic_automute(codec); */
7369 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7372 switch (res >> 26) {
7373 case ALC880_HP_EVENT:
7374 alc883_mitac_hp_automute(codec);
7376 case ALC880_MIC_EVENT:
7377 /* alc883_mitac_mic_automute(codec); */
7382 static struct hda_verb alc883_mitac_verbs[] = {
7384 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7385 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7387 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7388 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7390 /* enable unsolicited event */
7391 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7392 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7397 static struct hda_verb alc883_clevo_m720_verbs[] = {
7399 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7400 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7402 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7403 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7405 /* enable unsolicited event */
7406 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7407 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7412 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7414 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7415 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7417 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7418 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7420 /* enable unsolicited event */
7421 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7426 static struct hda_verb alc883_tagra_verbs[] = {
7427 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7428 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7430 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7431 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7433 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7434 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7435 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7437 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7438 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7439 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7440 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7445 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7446 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7447 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7448 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7452 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7453 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7454 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7455 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7456 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7460 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7461 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7462 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7463 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7464 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7465 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7469 static struct hda_verb alc883_haier_w66_verbs[] = {
7470 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7471 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7473 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7475 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7476 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7477 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7478 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7482 static struct hda_verb alc888_3st_hp_verbs[] = {
7483 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */
7484 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */
7485 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */
7489 static struct hda_verb alc888_6st_dell_verbs[] = {
7490 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7494 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7495 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7496 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7497 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7498 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7502 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7503 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7504 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7505 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7506 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7510 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7511 { 2, alc888_3st_hp_2ch_init },
7512 { 6, alc888_3st_hp_6ch_init },
7515 /* toggle front-jack and RCA according to the hp-jack state */
7516 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7518 unsigned int present;
7520 present = snd_hda_codec_read(codec, 0x1b, 0,
7521 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7522 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7523 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7524 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7525 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7528 /* toggle RCA according to the front-jack state */
7529 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7531 unsigned int present;
7533 present = snd_hda_codec_read(codec, 0x14, 0,
7534 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7535 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7536 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7539 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7542 if ((res >> 26) == ALC880_HP_EVENT)
7543 alc888_lenovo_ms7195_front_automute(codec);
7544 if ((res >> 26) == ALC880_FRONT_EVENT)
7545 alc888_lenovo_ms7195_rca_automute(codec);
7548 static struct hda_verb alc883_medion_md2_verbs[] = {
7549 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7550 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7552 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7554 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7558 /* toggle speaker-output according to the hp-jack state */
7559 static void alc883_medion_md2_automute(struct hda_codec *codec)
7561 unsigned int present;
7563 present = snd_hda_codec_read(codec, 0x14, 0,
7564 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7565 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7566 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7569 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7572 if ((res >> 26) == ALC880_HP_EVENT)
7573 alc883_medion_md2_automute(codec);
7576 /* toggle speaker-output according to the hp-jack state */
7577 static void alc883_tagra_automute(struct hda_codec *codec)
7579 unsigned int present;
7582 present = snd_hda_codec_read(codec, 0x14, 0,
7583 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7584 bits = present ? HDA_AMP_MUTE : 0;
7585 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7586 HDA_AMP_MUTE, bits);
7587 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7591 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7593 if ((res >> 26) == ALC880_HP_EVENT)
7594 alc883_tagra_automute(codec);
7597 /* toggle speaker-output according to the hp-jack state */
7598 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
7600 unsigned int present;
7603 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
7604 & AC_PINSENSE_PRESENCE;
7605 bits = present ? HDA_AMP_MUTE : 0;
7606 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7607 HDA_AMP_MUTE, bits);
7610 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
7612 unsigned int present;
7614 present = snd_hda_codec_read(codec, 0x18, 0,
7615 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7616 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
7617 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7620 static void alc883_clevo_m720_automute(struct hda_codec *codec)
7622 alc883_clevo_m720_hp_automute(codec);
7623 alc883_clevo_m720_mic_automute(codec);
7626 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
7629 switch (res >> 26) {
7630 case ALC880_HP_EVENT:
7631 alc883_clevo_m720_hp_automute(codec);
7633 case ALC880_MIC_EVENT:
7634 alc883_clevo_m720_mic_automute(codec);
7639 /* toggle speaker-output according to the hp-jack state */
7640 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
7642 unsigned int present;
7645 present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
7646 & AC_PINSENSE_PRESENCE;
7647 bits = present ? HDA_AMP_MUTE : 0;
7648 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7649 HDA_AMP_MUTE, bits);
7652 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
7655 if ((res >> 26) == ALC880_HP_EVENT)
7656 alc883_2ch_fujitsu_pi2515_automute(codec);
7659 static void alc883_haier_w66_automute(struct hda_codec *codec)
7661 unsigned int present;
7664 present = snd_hda_codec_read(codec, 0x1b, 0,
7665 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7666 bits = present ? 0x80 : 0;
7667 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7671 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
7674 if ((res >> 26) == ALC880_HP_EVENT)
7675 alc883_haier_w66_automute(codec);
7678 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
7680 unsigned int present;
7683 present = snd_hda_codec_read(codec, 0x14, 0,
7684 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7685 bits = present ? HDA_AMP_MUTE : 0;
7686 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7687 HDA_AMP_MUTE, bits);
7690 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
7692 unsigned int present;
7695 present = snd_hda_codec_read(codec, 0x1b, 0,
7696 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7697 bits = present ? HDA_AMP_MUTE : 0;
7698 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7699 HDA_AMP_MUTE, bits);
7700 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7701 HDA_AMP_MUTE, bits);
7704 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
7707 if ((res >> 26) == ALC880_HP_EVENT)
7708 alc883_lenovo_101e_all_automute(codec);
7709 if ((res >> 26) == ALC880_FRONT_EVENT)
7710 alc883_lenovo_101e_ispeaker_automute(codec);
7713 /* toggle speaker-output according to the hp-jack state */
7714 static void alc883_acer_aspire_automute(struct hda_codec *codec)
7716 unsigned int present;
7718 present = snd_hda_codec_read(codec, 0x14, 0,
7719 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7720 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7721 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7722 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7723 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7726 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
7729 if ((res >> 26) == ALC880_HP_EVENT)
7730 alc883_acer_aspire_automute(codec);
7733 static struct hda_verb alc883_acer_eapd_verbs[] = {
7734 /* HP Pin: output 0 (0x0c) */
7735 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7736 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7737 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7738 /* Front Pin: output 0 (0x0c) */
7739 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7740 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7741 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7742 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
7743 /* eanable EAPD on medion laptop */
7744 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7745 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
7746 /* enable unsolicited event */
7747 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7751 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
7753 unsigned int present;
7755 present = snd_hda_codec_read(codec, 0x1b, 0,
7756 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7757 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7758 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7759 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7760 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7761 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7762 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7763 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7764 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7767 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
7770 switch (res >> 26) {
7771 case ALC880_HP_EVENT:
7772 printk("hp_event\n");
7773 alc888_6st_dell_front_automute(codec);
7779 * generic initialization of ADC, input mixers and output mixers
7781 static struct hda_verb alc883_auto_init_verbs[] = {
7783 * Unmute ADC0-2 and set the default input to mic-in
7785 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7786 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7787 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7788 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7790 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7792 * Note: PASD motherboards uses the Line In 2 as the input for
7793 * front panel mic (mic 2)
7795 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7796 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7797 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7798 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7799 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7800 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7803 * Set up output mixers (0x0c - 0x0f)
7805 /* set vol=0 to output mixers */
7806 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7807 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7808 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7809 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7810 /* set up input amps for analog loopback */
7811 /* Amp Indices: DAC = 0, mixer = 1 */
7812 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7813 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7814 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7815 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7816 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7817 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7818 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7819 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7820 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7821 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7823 /* FIXME: use matrix-type input source selection */
7824 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7826 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7827 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7828 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7829 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7830 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7832 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7833 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7834 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7835 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7836 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7841 /* capture mixer elements */
7842 static struct snd_kcontrol_new alc883_capture_mixer[] = {
7843 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7844 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7845 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7846 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7848 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7849 /* The multiple "Capture Source" controls confuse alsamixer
7850 * So call somewhat different..
7852 /* .name = "Capture Source", */
7853 .name = "Input Source",
7855 .info = alc882_mux_enum_info,
7856 .get = alc882_mux_enum_get,
7857 .put = alc882_mux_enum_put,
7862 #ifdef CONFIG_SND_HDA_POWER_SAVE
7863 #define alc883_loopbacks alc880_loopbacks
7866 /* pcm configuration: identiacal with ALC880 */
7867 #define alc883_pcm_analog_playback alc880_pcm_analog_playback
7868 #define alc883_pcm_analog_capture alc880_pcm_analog_capture
7869 #define alc883_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
7870 #define alc883_pcm_digital_playback alc880_pcm_digital_playback
7871 #define alc883_pcm_digital_capture alc880_pcm_digital_capture
7874 * configuration and preset
7876 static const char *alc883_models[ALC883_MODEL_LAST] = {
7877 [ALC883_3ST_2ch_DIG] = "3stack-dig",
7878 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig",
7879 [ALC883_3ST_6ch] = "3stack-6ch",
7880 [ALC883_6ST_DIG] = "6stack-dig",
7881 [ALC883_TARGA_DIG] = "targa-dig",
7882 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig",
7883 [ALC883_ACER] = "acer",
7884 [ALC883_ACER_ASPIRE] = "acer-aspire",
7885 [ALC883_MEDION] = "medion",
7886 [ALC883_MEDION_MD2] = "medion-md2",
7887 [ALC883_LAPTOP_EAPD] = "laptop-eapd",
7888 [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
7889 [ALC883_LENOVO_NB0763] = "lenovo-nb0763",
7890 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
7891 [ALC883_HAIER_W66] = "haier-w66",
7892 [ALC888_3ST_HP] = "3stack-hp",
7893 [ALC888_6ST_DELL] = "6stack-dell",
7894 [ALC883_MITAC] = "mitac",
7895 [ALC883_CLEVO_M720] = "clevo-m720",
7896 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
7897 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel",
7898 [ALC883_AUTO] = "auto",
7901 static struct snd_pci_quirk alc883_cfg_tbl[] = {
7902 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
7903 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
7904 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
7905 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
7906 SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
7907 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
7908 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
7909 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
7910 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
7911 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
7912 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
7913 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
7914 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
7915 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
7916 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
7917 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
7918 SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
7919 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
7920 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
7921 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
7922 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
7923 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
7924 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
7925 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
7926 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
7927 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
7928 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
7929 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
7930 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
7931 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
7932 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
7933 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
7934 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
7935 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
7936 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
7937 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
7938 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
7939 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
7940 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
7941 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
7942 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
7943 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
7944 SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
7945 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
7946 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
7947 SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
7948 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
7949 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7950 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7951 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7952 SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
7953 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
7954 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
7955 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
7956 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
7957 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
7961 static struct alc_config_preset alc883_presets[] = {
7962 [ALC883_3ST_2ch_DIG] = {
7963 .mixers = { alc883_3ST_2ch_mixer },
7964 .init_verbs = { alc883_init_verbs },
7965 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7966 .dac_nids = alc883_dac_nids,
7967 .dig_out_nid = ALC883_DIGOUT_NID,
7968 .dig_in_nid = ALC883_DIGIN_NID,
7969 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7970 .channel_mode = alc883_3ST_2ch_modes,
7971 .input_mux = &alc883_capture_source,
7973 [ALC883_3ST_6ch_DIG] = {
7974 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
7975 .init_verbs = { alc883_init_verbs },
7976 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7977 .dac_nids = alc883_dac_nids,
7978 .dig_out_nid = ALC883_DIGOUT_NID,
7979 .dig_in_nid = ALC883_DIGIN_NID,
7980 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7981 .channel_mode = alc883_3ST_6ch_modes,
7983 .input_mux = &alc883_capture_source,
7985 [ALC883_3ST_6ch] = {
7986 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
7987 .init_verbs = { alc883_init_verbs },
7988 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7989 .dac_nids = alc883_dac_nids,
7990 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7991 .channel_mode = alc883_3ST_6ch_modes,
7993 .input_mux = &alc883_capture_source,
7995 [ALC883_3ST_6ch_INTEL] = {
7996 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
7997 .init_verbs = { alc883_init_verbs },
7998 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7999 .dac_nids = alc883_dac_nids,
8000 .dig_out_nid = ALC883_DIGOUT_NID,
8001 .dig_in_nid = ALC883_DIGIN_NID,
8002 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8003 .channel_mode = alc883_3ST_6ch_intel_modes,
8005 .input_mux = &alc883_3stack_6ch_intel,
8007 [ALC883_6ST_DIG] = {
8008 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8009 .init_verbs = { alc883_init_verbs },
8010 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8011 .dac_nids = alc883_dac_nids,
8012 .dig_out_nid = ALC883_DIGOUT_NID,
8013 .dig_in_nid = ALC883_DIGIN_NID,
8014 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8015 .channel_mode = alc883_sixstack_modes,
8016 .input_mux = &alc883_capture_source,
8018 [ALC883_TARGA_DIG] = {
8019 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8020 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8021 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8022 .dac_nids = alc883_dac_nids,
8023 .dig_out_nid = ALC883_DIGOUT_NID,
8024 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8025 .channel_mode = alc883_3ST_6ch_modes,
8027 .input_mux = &alc883_capture_source,
8028 .unsol_event = alc883_tagra_unsol_event,
8029 .init_hook = alc883_tagra_automute,
8031 [ALC883_TARGA_2ch_DIG] = {
8032 .mixers = { alc883_tagra_2ch_mixer},
8033 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8034 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8035 .dac_nids = alc883_dac_nids,
8036 .dig_out_nid = ALC883_DIGOUT_NID,
8037 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8038 .channel_mode = alc883_3ST_2ch_modes,
8039 .input_mux = &alc883_capture_source,
8040 .unsol_event = alc883_tagra_unsol_event,
8041 .init_hook = alc883_tagra_automute,
8044 .mixers = { alc883_base_mixer },
8045 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8046 * and the headphone jack. Turn this on and rely on the
8047 * standard mute methods whenever the user wants to turn
8048 * these outputs off.
8050 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8051 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8052 .dac_nids = alc883_dac_nids,
8053 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8054 .channel_mode = alc883_3ST_2ch_modes,
8055 .input_mux = &alc883_capture_source,
8057 [ALC883_ACER_ASPIRE] = {
8058 .mixers = { alc883_acer_aspire_mixer },
8059 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8060 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8061 .dac_nids = alc883_dac_nids,
8062 .dig_out_nid = ALC883_DIGOUT_NID,
8063 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8064 .channel_mode = alc883_3ST_2ch_modes,
8065 .input_mux = &alc883_capture_source,
8066 .unsol_event = alc883_acer_aspire_unsol_event,
8067 .init_hook = alc883_acer_aspire_automute,
8070 .mixers = { alc883_fivestack_mixer,
8071 alc883_chmode_mixer },
8072 .init_verbs = { alc883_init_verbs,
8073 alc883_medion_eapd_verbs },
8074 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8075 .dac_nids = alc883_dac_nids,
8076 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8077 .channel_mode = alc883_sixstack_modes,
8078 .input_mux = &alc883_capture_source,
8080 [ALC883_MEDION_MD2] = {
8081 .mixers = { alc883_medion_md2_mixer},
8082 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8083 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8084 .dac_nids = alc883_dac_nids,
8085 .dig_out_nid = ALC883_DIGOUT_NID,
8086 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8087 .channel_mode = alc883_3ST_2ch_modes,
8088 .input_mux = &alc883_capture_source,
8089 .unsol_event = alc883_medion_md2_unsol_event,
8090 .init_hook = alc883_medion_md2_automute,
8092 [ALC883_LAPTOP_EAPD] = {
8093 .mixers = { alc883_base_mixer },
8094 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8095 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8096 .dac_nids = alc883_dac_nids,
8097 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8098 .channel_mode = alc883_3ST_2ch_modes,
8099 .input_mux = &alc883_capture_source,
8101 [ALC883_CLEVO_M720] = {
8102 .mixers = { alc883_clevo_m720_mixer },
8103 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8104 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8105 .dac_nids = alc883_dac_nids,
8106 .dig_out_nid = ALC883_DIGOUT_NID,
8107 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8108 .channel_mode = alc883_3ST_2ch_modes,
8109 .input_mux = &alc883_capture_source,
8110 .unsol_event = alc883_clevo_m720_unsol_event,
8111 .init_hook = alc883_clevo_m720_automute,
8113 [ALC883_LENOVO_101E_2ch] = {
8114 .mixers = { alc883_lenovo_101e_2ch_mixer},
8115 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8116 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8117 .dac_nids = alc883_dac_nids,
8118 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8119 .channel_mode = alc883_3ST_2ch_modes,
8120 .input_mux = &alc883_lenovo_101e_capture_source,
8121 .unsol_event = alc883_lenovo_101e_unsol_event,
8122 .init_hook = alc883_lenovo_101e_all_automute,
8124 [ALC883_LENOVO_NB0763] = {
8125 .mixers = { alc883_lenovo_nb0763_mixer },
8126 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8127 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8128 .dac_nids = alc883_dac_nids,
8129 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8130 .channel_mode = alc883_3ST_2ch_modes,
8132 .input_mux = &alc883_lenovo_nb0763_capture_source,
8133 .unsol_event = alc883_medion_md2_unsol_event,
8134 .init_hook = alc883_medion_md2_automute,
8136 [ALC888_LENOVO_MS7195_DIG] = {
8137 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8138 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8139 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8140 .dac_nids = alc883_dac_nids,
8141 .dig_out_nid = ALC883_DIGOUT_NID,
8142 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8143 .channel_mode = alc883_3ST_6ch_modes,
8145 .input_mux = &alc883_capture_source,
8146 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8147 .init_hook = alc888_lenovo_ms7195_front_automute,
8149 [ALC883_HAIER_W66] = {
8150 .mixers = { alc883_tagra_2ch_mixer},
8151 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8152 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8153 .dac_nids = alc883_dac_nids,
8154 .dig_out_nid = ALC883_DIGOUT_NID,
8155 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8156 .channel_mode = alc883_3ST_2ch_modes,
8157 .input_mux = &alc883_capture_source,
8158 .unsol_event = alc883_haier_w66_unsol_event,
8159 .init_hook = alc883_haier_w66_automute,
8162 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8163 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8164 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8165 .dac_nids = alc883_dac_nids,
8166 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8167 .channel_mode = alc888_3st_hp_modes,
8169 .input_mux = &alc883_capture_source,
8171 [ALC888_6ST_DELL] = {
8172 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8173 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8174 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8175 .dac_nids = alc883_dac_nids,
8176 .dig_out_nid = ALC883_DIGOUT_NID,
8177 .dig_in_nid = ALC883_DIGIN_NID,
8178 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8179 .channel_mode = alc883_sixstack_modes,
8180 .input_mux = &alc883_capture_source,
8181 .unsol_event = alc888_6st_dell_unsol_event,
8182 .init_hook = alc888_6st_dell_front_automute,
8185 .mixers = { alc883_mitac_mixer },
8186 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8187 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8188 .dac_nids = alc883_dac_nids,
8189 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8190 .channel_mode = alc883_3ST_2ch_modes,
8191 .input_mux = &alc883_capture_source,
8192 .unsol_event = alc883_mitac_unsol_event,
8193 .init_hook = alc883_mitac_automute,
8195 [ALC883_FUJITSU_PI2515] = {
8196 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8197 .init_verbs = { alc883_init_verbs,
8198 alc883_2ch_fujitsu_pi2515_verbs},
8199 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8200 .dac_nids = alc883_dac_nids,
8201 .dig_out_nid = ALC883_DIGOUT_NID,
8202 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8203 .channel_mode = alc883_3ST_2ch_modes,
8204 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8205 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8206 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8212 * BIOS auto configuration
8214 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8215 hda_nid_t nid, int pin_type,
8219 struct alc_spec *spec = codec->spec;
8222 alc_set_pin_output(codec, nid, pin_type);
8223 if (spec->multiout.dac_nids[dac_idx] == 0x25)
8226 idx = spec->multiout.dac_nids[dac_idx] - 2;
8227 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8231 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8233 struct alc_spec *spec = codec->spec;
8236 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8237 for (i = 0; i <= HDA_SIDE; i++) {
8238 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8239 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8241 alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8246 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8248 struct alc_spec *spec = codec->spec;
8251 pin = spec->autocfg.hp_pins[0];
8252 if (pin) /* connect to front */
8254 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8255 pin = spec->autocfg.speaker_pins[0];
8257 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8260 #define alc883_is_input_pin(nid) alc880_is_input_pin(nid)
8261 #define ALC883_PIN_CD_NID ALC880_PIN_CD_NID
8263 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8265 struct alc_spec *spec = codec->spec;
8268 for (i = 0; i < AUTO_PIN_LAST; i++) {
8269 hda_nid_t nid = spec->autocfg.input_pins[i];
8270 if (alc883_is_input_pin(nid)) {
8271 snd_hda_codec_write(codec, nid, 0,
8272 AC_VERB_SET_PIN_WIDGET_CONTROL,
8273 (i <= AUTO_PIN_FRONT_MIC ?
8274 PIN_VREF80 : PIN_IN));
8275 if (nid != ALC883_PIN_CD_NID)
8276 snd_hda_codec_write(codec, nid, 0,
8277 AC_VERB_SET_AMP_GAIN_MUTE,
8283 /* almost identical with ALC880 parser... */
8284 static int alc883_parse_auto_config(struct hda_codec *codec)
8286 struct alc_spec *spec = codec->spec;
8287 int err = alc880_parse_auto_config(codec);
8292 return 0; /* no config found */
8294 err = alc_auto_add_mic_boost(codec);
8298 /* hack - override the init verbs */
8299 spec->init_verbs[0] = alc883_auto_init_verbs;
8300 spec->mixers[spec->num_mixers] = alc883_capture_mixer;
8303 return 1; /* config found */
8306 /* additional initialization for auto-configuration model */
8307 static void alc883_auto_init(struct hda_codec *codec)
8309 struct alc_spec *spec = codec->spec;
8310 alc883_auto_init_multi_out(codec);
8311 alc883_auto_init_hp_out(codec);
8312 alc883_auto_init_analog_input(codec);
8313 if (spec->unsol_event)
8314 alc_sku_automute(codec);
8317 static int patch_alc883(struct hda_codec *codec)
8319 struct alc_spec *spec;
8320 int err, board_config;
8322 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8328 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
8330 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
8333 if (board_config < 0) {
8334 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
8335 "trying auto-probe from BIOS...\n");
8336 board_config = ALC883_AUTO;
8339 if (board_config == ALC883_AUTO) {
8340 /* automatic parse from the BIOS config */
8341 err = alc883_parse_auto_config(codec);
8347 "hda_codec: Cannot set up configuration "
8348 "from BIOS. Using base mode...\n");
8349 board_config = ALC883_3ST_2ch_DIG;
8353 if (board_config != ALC883_AUTO)
8354 setup_preset(spec, &alc883_presets[board_config]);
8356 switch (codec->vendor_id) {
8358 spec->stream_name_analog = "ALC888 Analog";
8359 spec->stream_name_digital = "ALC888 Digital";
8362 spec->stream_name_analog = "ALC889 Analog";
8363 spec->stream_name_digital = "ALC889 Digital";
8366 spec->stream_name_analog = "ALC883 Analog";
8367 spec->stream_name_digital = "ALC883 Digital";
8371 spec->stream_analog_playback = &alc883_pcm_analog_playback;
8372 spec->stream_analog_capture = &alc883_pcm_analog_capture;
8373 spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8375 spec->stream_digital_playback = &alc883_pcm_digital_playback;
8376 spec->stream_digital_capture = &alc883_pcm_digital_capture;
8378 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8379 spec->adc_nids = alc883_adc_nids;
8380 spec->capsrc_nids = alc883_capsrc_nids;
8382 spec->vmaster_nid = 0x0c;
8384 codec->patch_ops = alc_patch_ops;
8385 if (board_config == ALC883_AUTO)
8386 spec->init_hook = alc883_auto_init;
8387 else if (codec->vendor_id == 0x10ec0888)
8388 spec->init_hook = alc888_coef_init;
8390 #ifdef CONFIG_SND_HDA_POWER_SAVE
8391 if (!spec->loopback.amplist)
8392 spec->loopback.amplist = alc883_loopbacks;
8402 #define ALC262_DIGOUT_NID ALC880_DIGOUT_NID
8403 #define ALC262_DIGIN_NID ALC880_DIGIN_NID
8405 #define alc262_dac_nids alc260_dac_nids
8406 #define alc262_adc_nids alc882_adc_nids
8407 #define alc262_adc_nids_alt alc882_adc_nids_alt
8408 #define alc262_capsrc_nids alc882_capsrc_nids
8409 #define alc262_capsrc_nids_alt alc882_capsrc_nids_alt
8411 #define alc262_modes alc260_modes
8412 #define alc262_capture_source alc882_capture_source
8414 static struct snd_kcontrol_new alc262_base_mixer[] = {
8415 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8416 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8417 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8418 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8419 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8420 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8421 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8422 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8423 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8424 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8425 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8426 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8427 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8428 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8429 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8430 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8431 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8432 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
8436 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
8437 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8438 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8439 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8440 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8441 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8442 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8443 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8444 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8445 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8446 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8447 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8448 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8449 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8450 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8451 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
8452 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8456 /* update HP, line and mono-out pins according to the master switch */
8457 static void alc262_hp_master_update(struct hda_codec *codec)
8459 struct alc_spec *spec = codec->spec;
8460 int val = spec->master_sw;
8463 snd_hda_codec_write_cache(codec, 0x1b, 0,
8464 AC_VERB_SET_PIN_WIDGET_CONTROL,
8466 snd_hda_codec_write_cache(codec, 0x15, 0,
8467 AC_VERB_SET_PIN_WIDGET_CONTROL,
8469 /* mono (speaker) depending on the HP jack sense */
8470 val = val && !spec->jack_present;
8471 snd_hda_codec_write_cache(codec, 0x16, 0,
8472 AC_VERB_SET_PIN_WIDGET_CONTROL,
8476 static void alc262_hp_bpc_automute(struct hda_codec *codec)
8478 struct alc_spec *spec = codec->spec;
8479 unsigned int presence;
8480 presence = snd_hda_codec_read(codec, 0x1b, 0,
8481 AC_VERB_GET_PIN_SENSE, 0);
8482 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8483 alc262_hp_master_update(codec);
8486 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
8488 if ((res >> 26) != ALC880_HP_EVENT)
8490 alc262_hp_bpc_automute(codec);
8493 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
8495 struct alc_spec *spec = codec->spec;
8496 unsigned int presence;
8497 presence = snd_hda_codec_read(codec, 0x15, 0,
8498 AC_VERB_GET_PIN_SENSE, 0);
8499 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8500 alc262_hp_master_update(codec);
8503 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
8506 if ((res >> 26) != ALC880_HP_EVENT)
8508 alc262_hp_wildwest_automute(codec);
8511 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
8512 struct snd_ctl_elem_value *ucontrol)
8514 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8515 struct alc_spec *spec = codec->spec;
8516 *ucontrol->value.integer.value = spec->master_sw;
8520 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
8521 struct snd_ctl_elem_value *ucontrol)
8523 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8524 struct alc_spec *spec = codec->spec;
8525 int val = !!*ucontrol->value.integer.value;
8527 if (val == spec->master_sw)
8529 spec->master_sw = val;
8530 alc262_hp_master_update(codec);
8534 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
8536 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8537 .name = "Master Playback Switch",
8538 .info = snd_ctl_boolean_mono_info,
8539 .get = alc262_hp_master_sw_get,
8540 .put = alc262_hp_master_sw_put,
8542 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8543 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8544 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8545 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8547 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8549 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8550 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8551 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8552 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8553 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8554 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8555 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8556 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8557 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8558 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8559 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8560 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8561 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
8562 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
8566 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
8568 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8569 .name = "Master Playback Switch",
8570 .info = snd_ctl_boolean_mono_info,
8571 .get = alc262_hp_master_sw_get,
8572 .put = alc262_hp_master_sw_put,
8574 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8575 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8576 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8577 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8578 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8580 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8582 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
8583 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
8584 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
8585 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8586 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8587 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8588 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8589 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8590 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8594 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
8595 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8596 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8597 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
8601 /* mute/unmute internal speaker according to the hp jack and mute state */
8602 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
8604 struct alc_spec *spec = codec->spec;
8606 if (force || !spec->sense_updated) {
8607 unsigned int present;
8608 present = snd_hda_codec_read(codec, 0x15, 0,
8609 AC_VERB_GET_PIN_SENSE, 0);
8610 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
8611 spec->sense_updated = 1;
8613 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
8614 spec->jack_present ? HDA_AMP_MUTE : 0);
8617 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
8620 if ((res >> 26) != ALC880_HP_EVENT)
8622 alc262_hp_t5735_automute(codec, 1);
8625 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
8627 alc262_hp_t5735_automute(codec, 1);
8630 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
8631 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8632 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8633 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8634 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8635 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8636 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8637 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8641 static struct hda_verb alc262_hp_t5735_verbs[] = {
8642 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8643 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8645 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8649 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
8650 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8651 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8652 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8653 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8654 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8655 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8659 static struct hda_verb alc262_hp_rp5700_verbs[] = {
8660 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8661 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8662 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8663 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8664 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8665 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8666 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8667 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8668 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8669 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8673 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
8680 /* bind hp and internal speaker mute (with plug check) */
8681 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
8682 struct snd_ctl_elem_value *ucontrol)
8684 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8685 long *valp = ucontrol->value.integer.value;
8688 /* change hp mute */
8689 change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
8691 valp[0] ? 0 : HDA_AMP_MUTE);
8692 change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
8694 valp[1] ? 0 : HDA_AMP_MUTE);
8696 /* change speaker according to HP jack state */
8697 struct alc_spec *spec = codec->spec;
8699 if (spec->jack_present)
8700 mute = HDA_AMP_MUTE;
8702 mute = snd_hda_codec_amp_read(codec, 0x15, 0,
8704 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8705 HDA_AMP_MUTE, mute);
8710 static struct snd_kcontrol_new alc262_sony_mixer[] = {
8711 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8713 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8714 .name = "Master Playback Switch",
8715 .info = snd_hda_mixer_amp_switch_info,
8716 .get = snd_hda_mixer_amp_switch_get,
8717 .put = alc262_sony_master_sw_put,
8718 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
8720 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8721 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8722 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8723 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8727 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
8728 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8729 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8730 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8731 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8732 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8733 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8734 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8738 #define alc262_capture_mixer alc882_capture_mixer
8739 #define alc262_capture_alt_mixer alc882_capture_alt_mixer
8742 * generic initialization of ADC, input mixers and output mixers
8744 static struct hda_verb alc262_init_verbs[] = {
8746 * Unmute ADC0-2 and set the default input to mic-in
8748 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8749 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8750 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8751 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8752 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8753 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8755 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8757 * Note: PASD motherboards uses the Line In 2 as the input for
8758 * front panel mic (mic 2)
8760 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8761 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8762 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8763 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8764 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8765 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8768 * Set up output mixers (0x0c - 0x0e)
8770 /* set vol=0 to output mixers */
8771 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8772 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8773 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8774 /* set up input amps for analog loopback */
8775 /* Amp Indices: DAC = 0, mixer = 1 */
8776 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8777 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8778 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8779 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8780 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8781 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8783 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8784 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8785 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8786 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8787 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8788 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8790 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8791 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8792 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8793 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8794 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8796 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8797 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8799 /* FIXME: use matrix-type input source selection */
8800 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8801 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8802 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8803 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8804 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8805 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8807 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8808 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8809 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8810 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8812 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8813 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8814 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8815 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8820 static struct hda_verb alc262_hippo_unsol_verbs[] = {
8821 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8822 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8826 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
8827 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8828 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8829 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8831 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8832 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8836 static struct hda_verb alc262_sony_unsol_verbs[] = {
8837 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8838 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8839 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic
8841 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8842 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8846 /* mute/unmute internal speaker according to the hp jack and mute state */
8847 static void alc262_hippo_automute(struct hda_codec *codec)
8849 struct alc_spec *spec = codec->spec;
8851 unsigned int present;
8853 /* need to execute and sync at first */
8854 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
8855 present = snd_hda_codec_read(codec, 0x15, 0,
8856 AC_VERB_GET_PIN_SENSE, 0);
8857 spec->jack_present = (present & 0x80000000) != 0;
8858 if (spec->jack_present) {
8859 /* mute internal speaker */
8860 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8861 HDA_AMP_MUTE, HDA_AMP_MUTE);
8863 /* unmute internal speaker if necessary */
8864 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
8865 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8866 HDA_AMP_MUTE, mute);
8870 /* unsolicited event for HP jack sensing */
8871 static void alc262_hippo_unsol_event(struct hda_codec *codec,
8874 if ((res >> 26) != ALC880_HP_EVENT)
8876 alc262_hippo_automute(codec);
8879 static void alc262_hippo1_automute(struct hda_codec *codec)
8882 unsigned int present;
8884 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8885 present = snd_hda_codec_read(codec, 0x1b, 0,
8886 AC_VERB_GET_PIN_SENSE, 0);
8887 present = (present & 0x80000000) != 0;
8889 /* mute internal speaker */
8890 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8891 HDA_AMP_MUTE, HDA_AMP_MUTE);
8893 /* unmute internal speaker if necessary */
8894 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8895 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8896 HDA_AMP_MUTE, mute);
8900 /* unsolicited event for HP jack sensing */
8901 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
8904 if ((res >> 26) != ALC880_HP_EVENT)
8906 alc262_hippo1_automute(codec);
8911 * 0x14 = headphone/spdif-out, 0x15 = internal speaker,
8912 * 0x1b = port replicator headphone out
8915 #define ALC_HP_EVENT 0x37
8917 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
8918 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8919 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8920 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8921 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8925 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
8926 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8927 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8931 static struct hda_input_mux alc262_fujitsu_capture_source = {
8940 static struct hda_input_mux alc262_HP_capture_source = {
8944 { "Front Mic", 0x1 },
8951 static struct hda_input_mux alc262_HP_D7000_capture_source = {
8955 { "Front Mic", 0x2 },
8961 /* mute/unmute internal speaker according to the hp jacks and mute state */
8962 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
8964 struct alc_spec *spec = codec->spec;
8967 if (force || !spec->sense_updated) {
8968 unsigned int present;
8969 /* need to execute and sync at first */
8970 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
8971 /* check laptop HP jack */
8972 present = snd_hda_codec_read(codec, 0x14, 0,
8973 AC_VERB_GET_PIN_SENSE, 0);
8974 /* need to execute and sync at first */
8975 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8976 /* check docking HP jack */
8977 present |= snd_hda_codec_read(codec, 0x1b, 0,
8978 AC_VERB_GET_PIN_SENSE, 0);
8979 if (present & AC_PINSENSE_PRESENCE)
8980 spec->jack_present = 1;
8982 spec->jack_present = 0;
8983 spec->sense_updated = 1;
8985 /* unmute internal speaker only if both HPs are unplugged and
8986 * master switch is on
8988 if (spec->jack_present)
8989 mute = HDA_AMP_MUTE;
8991 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
8992 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8993 HDA_AMP_MUTE, mute);
8996 /* unsolicited event for HP jack sensing */
8997 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9000 if ((res >> 26) != ALC_HP_EVENT)
9002 alc262_fujitsu_automute(codec, 1);
9005 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9007 alc262_fujitsu_automute(codec, 1);
9010 /* bind volumes of both NID 0x0c and 0x0d */
9011 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9012 .ops = &snd_hda_bind_vol,
9014 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9015 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9020 /* mute/unmute internal speaker according to the hp jack and mute state */
9021 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9023 struct alc_spec *spec = codec->spec;
9026 if (force || !spec->sense_updated) {
9027 unsigned int present_int_hp;
9028 /* need to execute and sync at first */
9029 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9030 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9031 AC_VERB_GET_PIN_SENSE, 0);
9032 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9033 spec->sense_updated = 1;
9035 if (spec->jack_present) {
9036 /* mute internal speaker */
9037 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9038 HDA_AMP_MUTE, HDA_AMP_MUTE);
9039 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9040 HDA_AMP_MUTE, HDA_AMP_MUTE);
9042 /* unmute internal speaker if necessary */
9043 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9044 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9045 HDA_AMP_MUTE, mute);
9046 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9047 HDA_AMP_MUTE, mute);
9051 /* unsolicited event for HP jack sensing */
9052 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9055 if ((res >> 26) != ALC_HP_EVENT)
9057 alc262_lenovo_3000_automute(codec, 1);
9060 /* bind hp and internal speaker mute (with plug check) */
9061 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9062 struct snd_ctl_elem_value *ucontrol)
9064 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9065 long *valp = ucontrol->value.integer.value;
9068 change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9070 valp ? 0 : HDA_AMP_MUTE);
9071 change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9073 valp ? 0 : HDA_AMP_MUTE);
9076 alc262_fujitsu_automute(codec, 0);
9080 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9081 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9083 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9084 .name = "Master Playback Switch",
9085 .info = snd_hda_mixer_amp_switch_info,
9086 .get = snd_hda_mixer_amp_switch_get,
9087 .put = alc262_fujitsu_master_sw_put,
9088 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9090 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9091 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9092 HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9093 HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9094 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9095 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9096 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9097 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9098 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9099 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9103 /* bind hp and internal speaker mute (with plug check) */
9104 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9105 struct snd_ctl_elem_value *ucontrol)
9107 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9108 long *valp = ucontrol->value.integer.value;
9111 change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9113 valp ? 0 : HDA_AMP_MUTE);
9116 alc262_lenovo_3000_automute(codec, 0);
9120 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9121 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9123 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9124 .name = "Master Playback Switch",
9125 .info = snd_hda_mixer_amp_switch_info,
9126 .get = snd_hda_mixer_amp_switch_get,
9127 .put = alc262_lenovo_3000_master_sw_put,
9128 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9130 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9131 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9132 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9133 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9134 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9135 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9136 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9137 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9141 /* additional init verbs for Benq laptops */
9142 static struct hda_verb alc262_EAPD_verbs[] = {
9143 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9144 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
9148 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9149 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9150 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9152 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9153 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9157 /* Samsung Q1 Ultra Vista model setup */
9158 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9159 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9160 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9161 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9162 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9163 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9164 HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9168 static struct hda_verb alc262_ultra_verbs[] = {
9170 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9171 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9172 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9174 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9175 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9176 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9177 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9179 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9180 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9181 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9182 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9183 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9185 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9186 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9187 /* ADC, choose mic */
9188 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9189 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9190 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9191 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9192 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9193 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9194 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9195 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9196 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9197 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9201 /* mute/unmute internal speaker according to the hp jack and mute state */
9202 static void alc262_ultra_automute(struct hda_codec *codec)
9204 struct alc_spec *spec = codec->spec;
9208 /* auto-mute only when HP is used as HP */
9209 if (!spec->cur_mux[0]) {
9210 unsigned int present;
9211 /* need to execute and sync at first */
9212 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9213 present = snd_hda_codec_read(codec, 0x15, 0,
9214 AC_VERB_GET_PIN_SENSE, 0);
9215 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9216 if (spec->jack_present)
9217 mute = HDA_AMP_MUTE;
9219 /* mute/unmute internal speaker */
9220 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9221 HDA_AMP_MUTE, mute);
9222 /* mute/unmute HP */
9223 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9224 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9227 /* unsolicited event for HP jack sensing */
9228 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9231 if ((res >> 26) != ALC880_HP_EVENT)
9233 alc262_ultra_automute(codec);
9236 static struct hda_input_mux alc262_ultra_capture_source = {
9240 { "Headphone", 0x7 },
9244 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9245 struct snd_ctl_elem_value *ucontrol)
9247 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9248 struct alc_spec *spec = codec->spec;
9251 ret = alc882_mux_enum_put(kcontrol, ucontrol);
9254 /* reprogram the HP pin as mic or HP according to the input source */
9255 snd_hda_codec_write_cache(codec, 0x15, 0,
9256 AC_VERB_SET_PIN_WIDGET_CONTROL,
9257 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9258 alc262_ultra_automute(codec); /* mute/unmute HP */
9262 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9263 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9264 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9266 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9267 .name = "Capture Source",
9268 .info = alc882_mux_enum_info,
9269 .get = alc882_mux_enum_get,
9270 .put = alc262_ultra_mux_enum_put,
9275 /* add playback controls from the parsed DAC table */
9276 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9277 const struct auto_pin_cfg *cfg)
9282 spec->multiout.num_dacs = 1; /* only use one dac */
9283 spec->multiout.dac_nids = spec->private_dac_nids;
9284 spec->multiout.dac_nids[0] = 2;
9286 nid = cfg->line_out_pins[0];
9288 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9289 "Front Playback Volume",
9290 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
9293 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9294 "Front Playback Switch",
9295 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9300 nid = cfg->speaker_pins[0];
9303 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9304 "Speaker Playback Volume",
9305 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9309 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9310 "Speaker Playback Switch",
9311 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9316 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9317 "Speaker Playback Switch",
9318 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9324 nid = cfg->hp_pins[0];
9326 /* spec->multiout.hp_nid = 2; */
9328 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9329 "Headphone Playback Volume",
9330 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9334 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9335 "Headphone Playback Switch",
9336 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9341 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9342 "Headphone Playback Switch",
9343 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9352 /* identical with ALC880 */
9353 #define alc262_auto_create_analog_input_ctls \
9354 alc880_auto_create_analog_input_ctls
9357 * generic initialization of ADC, input mixers and output mixers
9359 static struct hda_verb alc262_volume_init_verbs[] = {
9361 * Unmute ADC0-2 and set the default input to mic-in
9363 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9364 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9365 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9366 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9367 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9368 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9370 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9372 * Note: PASD motherboards uses the Line In 2 as the input for
9373 * front panel mic (mic 2)
9375 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9376 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9377 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9378 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9379 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9380 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9383 * Set up output mixers (0x0c - 0x0f)
9385 /* set vol=0 to output mixers */
9386 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9387 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9388 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9390 /* set up input amps for analog loopback */
9391 /* Amp Indices: DAC = 0, mixer = 1 */
9392 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9393 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9394 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9395 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9396 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9397 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9399 /* FIXME: use matrix-type input source selection */
9400 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9401 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9402 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9403 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9404 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9405 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9407 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9408 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9409 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9410 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9412 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9413 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9414 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9415 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9420 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
9422 * Unmute ADC0-2 and set the default input to mic-in
9424 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9425 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9426 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9427 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9428 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9429 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9431 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9433 * Note: PASD motherboards uses the Line In 2 as the input for
9434 * front panel mic (mic 2)
9436 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9437 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9438 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9439 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9440 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9441 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9442 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9443 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9446 * Set up output mixers (0x0c - 0x0e)
9448 /* set vol=0 to output mixers */
9449 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9450 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9451 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9453 /* set up input amps for analog loopback */
9454 /* Amp Indices: DAC = 0, mixer = 1 */
9455 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9456 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9457 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9458 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9459 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9460 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9462 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9463 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9464 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9466 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9467 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9469 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9470 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9472 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9473 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9474 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9475 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9476 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9478 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9479 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9480 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9481 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9482 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9483 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9486 /* FIXME: use matrix-type input source selection */
9487 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9488 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9489 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9490 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9491 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9492 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9494 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9495 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9496 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9497 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9499 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9500 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9501 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9502 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9504 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9509 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
9511 * Unmute ADC0-2 and set the default input to mic-in
9513 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9514 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9515 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9516 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9517 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9518 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9520 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9522 * Note: PASD motherboards uses the Line In 2 as the input for front
9525 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9526 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9527 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9528 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9529 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9530 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9531 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9532 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9533 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9535 * Set up output mixers (0x0c - 0x0e)
9537 /* set vol=0 to output mixers */
9538 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9539 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9540 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9542 /* set up input amps for analog loopback */
9543 /* Amp Indices: DAC = 0, mixer = 1 */
9544 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9545 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9546 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9547 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9548 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9549 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9552 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */
9553 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */
9554 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */
9555 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */
9556 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
9557 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */
9558 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */
9560 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9561 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9563 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9564 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9566 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
9567 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9568 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9569 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9570 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9571 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9573 /* FIXME: use matrix-type input source selection */
9574 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9575 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9576 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
9577 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
9578 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
9579 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
9580 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
9581 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9582 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
9584 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9585 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9586 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9587 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9588 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9589 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9590 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9592 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9593 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9594 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9595 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9596 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9597 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9598 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9600 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9605 #ifdef CONFIG_SND_HDA_POWER_SAVE
9606 #define alc262_loopbacks alc880_loopbacks
9609 /* pcm configuration: identiacal with ALC880 */
9610 #define alc262_pcm_analog_playback alc880_pcm_analog_playback
9611 #define alc262_pcm_analog_capture alc880_pcm_analog_capture
9612 #define alc262_pcm_digital_playback alc880_pcm_digital_playback
9613 #define alc262_pcm_digital_capture alc880_pcm_digital_capture
9616 * BIOS auto configuration
9618 static int alc262_parse_auto_config(struct hda_codec *codec)
9620 struct alc_spec *spec = codec->spec;
9622 static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
9624 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9628 if (!spec->autocfg.line_outs)
9629 return 0; /* can't find valid BIOS pin config */
9630 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
9633 err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
9637 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9639 if (spec->autocfg.dig_out_pin)
9640 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
9641 if (spec->autocfg.dig_in_pin)
9642 spec->dig_in_nid = ALC262_DIGIN_NID;
9644 if (spec->kctl_alloc)
9645 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
9647 spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
9648 spec->num_mux_defs = 1;
9649 spec->input_mux = &spec->private_imux;
9651 err = alc_auto_add_mic_boost(codec);
9658 #define alc262_auto_init_multi_out alc882_auto_init_multi_out
9659 #define alc262_auto_init_hp_out alc882_auto_init_hp_out
9660 #define alc262_auto_init_analog_input alc882_auto_init_analog_input
9663 /* init callback for auto-configuration model -- overriding the default init */
9664 static void alc262_auto_init(struct hda_codec *codec)
9666 struct alc_spec *spec = codec->spec;
9667 alc262_auto_init_multi_out(codec);
9668 alc262_auto_init_hp_out(codec);
9669 alc262_auto_init_analog_input(codec);
9670 if (spec->unsol_event)
9671 alc_sku_automute(codec);
9675 * configuration and preset
9677 static const char *alc262_models[ALC262_MODEL_LAST] = {
9678 [ALC262_BASIC] = "basic",
9679 [ALC262_HIPPO] = "hippo",
9680 [ALC262_HIPPO_1] = "hippo_1",
9681 [ALC262_FUJITSU] = "fujitsu",
9682 [ALC262_HP_BPC] = "hp-bpc",
9683 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
9684 [ALC262_HP_TC_T5735] = "hp-tc-t5735",
9685 [ALC262_HP_RP5700] = "hp-rp5700",
9686 [ALC262_BENQ_ED8] = "benq",
9687 [ALC262_BENQ_T31] = "benq-t31",
9688 [ALC262_SONY_ASSAMD] = "sony-assamd",
9689 [ALC262_ULTRA] = "ultra",
9690 [ALC262_LENOVO_3000] = "lenovo-3000",
9691 [ALC262_AUTO] = "auto",
9694 static struct snd_pci_quirk alc262_cfg_tbl[] = {
9695 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
9696 SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
9697 SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
9698 SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
9699 SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
9700 SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
9701 SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
9702 SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
9703 SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
9704 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
9705 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
9706 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
9707 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
9708 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
9709 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
9710 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
9711 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
9712 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
9713 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
9714 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
9715 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
9716 ALC262_HP_TC_T5735),
9717 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
9718 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9719 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
9720 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9721 SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9722 SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
9723 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
9724 ALC262_SONY_ASSAMD),
9725 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
9726 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
9727 SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
9728 SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
9729 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
9730 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
9731 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
9732 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
9736 static struct alc_config_preset alc262_presets[] = {
9738 .mixers = { alc262_base_mixer },
9739 .init_verbs = { alc262_init_verbs },
9740 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9741 .dac_nids = alc262_dac_nids,
9743 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9744 .channel_mode = alc262_modes,
9745 .input_mux = &alc262_capture_source,
9748 .mixers = { alc262_base_mixer },
9749 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
9750 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9751 .dac_nids = alc262_dac_nids,
9753 .dig_out_nid = ALC262_DIGOUT_NID,
9754 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9755 .channel_mode = alc262_modes,
9756 .input_mux = &alc262_capture_source,
9757 .unsol_event = alc262_hippo_unsol_event,
9758 .init_hook = alc262_hippo_automute,
9760 [ALC262_HIPPO_1] = {
9761 .mixers = { alc262_hippo1_mixer },
9762 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
9763 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9764 .dac_nids = alc262_dac_nids,
9766 .dig_out_nid = ALC262_DIGOUT_NID,
9767 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9768 .channel_mode = alc262_modes,
9769 .input_mux = &alc262_capture_source,
9770 .unsol_event = alc262_hippo1_unsol_event,
9771 .init_hook = alc262_hippo1_automute,
9773 [ALC262_FUJITSU] = {
9774 .mixers = { alc262_fujitsu_mixer },
9775 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
9776 alc262_fujitsu_unsol_verbs },
9777 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9778 .dac_nids = alc262_dac_nids,
9780 .dig_out_nid = ALC262_DIGOUT_NID,
9781 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9782 .channel_mode = alc262_modes,
9783 .input_mux = &alc262_fujitsu_capture_source,
9784 .unsol_event = alc262_fujitsu_unsol_event,
9785 .init_hook = alc262_fujitsu_init_hook,
9788 .mixers = { alc262_HP_BPC_mixer },
9789 .init_verbs = { alc262_HP_BPC_init_verbs },
9790 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9791 .dac_nids = alc262_dac_nids,
9793 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9794 .channel_mode = alc262_modes,
9795 .input_mux = &alc262_HP_capture_source,
9796 .unsol_event = alc262_hp_bpc_unsol_event,
9797 .init_hook = alc262_hp_bpc_automute,
9799 [ALC262_HP_BPC_D7000_WF] = {
9800 .mixers = { alc262_HP_BPC_WildWest_mixer },
9801 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9802 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9803 .dac_nids = alc262_dac_nids,
9805 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9806 .channel_mode = alc262_modes,
9807 .input_mux = &alc262_HP_D7000_capture_source,
9808 .unsol_event = alc262_hp_wildwest_unsol_event,
9809 .init_hook = alc262_hp_wildwest_automute,
9811 [ALC262_HP_BPC_D7000_WL] = {
9812 .mixers = { alc262_HP_BPC_WildWest_mixer,
9813 alc262_HP_BPC_WildWest_option_mixer },
9814 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9815 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9816 .dac_nids = alc262_dac_nids,
9818 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9819 .channel_mode = alc262_modes,
9820 .input_mux = &alc262_HP_D7000_capture_source,
9821 .unsol_event = alc262_hp_wildwest_unsol_event,
9822 .init_hook = alc262_hp_wildwest_automute,
9824 [ALC262_HP_TC_T5735] = {
9825 .mixers = { alc262_hp_t5735_mixer },
9826 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
9827 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9828 .dac_nids = alc262_dac_nids,
9830 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9831 .channel_mode = alc262_modes,
9832 .input_mux = &alc262_capture_source,
9833 .unsol_event = alc262_hp_t5735_unsol_event,
9834 .init_hook = alc262_hp_t5735_init_hook,
9836 [ALC262_HP_RP5700] = {
9837 .mixers = { alc262_hp_rp5700_mixer },
9838 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
9839 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9840 .dac_nids = alc262_dac_nids,
9841 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9842 .channel_mode = alc262_modes,
9843 .input_mux = &alc262_hp_rp5700_capture_source,
9845 [ALC262_BENQ_ED8] = {
9846 .mixers = { alc262_base_mixer },
9847 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
9848 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9849 .dac_nids = alc262_dac_nids,
9851 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9852 .channel_mode = alc262_modes,
9853 .input_mux = &alc262_capture_source,
9855 [ALC262_SONY_ASSAMD] = {
9856 .mixers = { alc262_sony_mixer },
9857 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
9858 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9859 .dac_nids = alc262_dac_nids,
9861 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9862 .channel_mode = alc262_modes,
9863 .input_mux = &alc262_capture_source,
9864 .unsol_event = alc262_hippo_unsol_event,
9865 .init_hook = alc262_hippo_automute,
9867 [ALC262_BENQ_T31] = {
9868 .mixers = { alc262_benq_t31_mixer },
9869 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
9870 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9871 .dac_nids = alc262_dac_nids,
9873 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9874 .channel_mode = alc262_modes,
9875 .input_mux = &alc262_capture_source,
9876 .unsol_event = alc262_hippo_unsol_event,
9877 .init_hook = alc262_hippo_automute,
9880 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
9881 .init_verbs = { alc262_ultra_verbs },
9882 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9883 .dac_nids = alc262_dac_nids,
9884 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9885 .channel_mode = alc262_modes,
9886 .input_mux = &alc262_ultra_capture_source,
9887 .adc_nids = alc262_adc_nids, /* ADC0 */
9888 .capsrc_nids = alc262_capsrc_nids,
9889 .num_adc_nids = 1, /* single ADC */
9890 .unsol_event = alc262_ultra_unsol_event,
9891 .init_hook = alc262_ultra_automute,
9893 [ALC262_LENOVO_3000] = {
9894 .mixers = { alc262_lenovo_3000_mixer },
9895 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
9896 alc262_lenovo_3000_unsol_verbs },
9897 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9898 .dac_nids = alc262_dac_nids,
9900 .dig_out_nid = ALC262_DIGOUT_NID,
9901 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9902 .channel_mode = alc262_modes,
9903 .input_mux = &alc262_fujitsu_capture_source,
9904 .unsol_event = alc262_lenovo_3000_unsol_event,
9908 static int patch_alc262(struct hda_codec *codec)
9910 struct alc_spec *spec;
9914 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9920 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
9925 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9926 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
9927 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9928 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
9932 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9934 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
9938 if (board_config < 0) {
9939 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
9940 "trying auto-probe from BIOS...\n");
9941 board_config = ALC262_AUTO;
9944 if (board_config == ALC262_AUTO) {
9945 /* automatic parse from the BIOS config */
9946 err = alc262_parse_auto_config(codec);
9952 "hda_codec: Cannot set up configuration "
9953 "from BIOS. Using base mode...\n");
9954 board_config = ALC262_BASIC;
9958 if (board_config != ALC262_AUTO)
9959 setup_preset(spec, &alc262_presets[board_config]);
9961 spec->stream_name_analog = "ALC262 Analog";
9962 spec->stream_analog_playback = &alc262_pcm_analog_playback;
9963 spec->stream_analog_capture = &alc262_pcm_analog_capture;
9965 spec->stream_name_digital = "ALC262 Digital";
9966 spec->stream_digital_playback = &alc262_pcm_digital_playback;
9967 spec->stream_digital_capture = &alc262_pcm_digital_capture;
9969 if (!spec->adc_nids && spec->input_mux) {
9970 /* check whether NID 0x07 is valid */
9971 unsigned int wcap = get_wcaps(codec, 0x07);
9974 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
9975 if (wcap != AC_WID_AUD_IN) {
9976 spec->adc_nids = alc262_adc_nids_alt;
9977 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
9978 spec->capsrc_nids = alc262_capsrc_nids_alt;
9979 spec->mixers[spec->num_mixers] =
9980 alc262_capture_alt_mixer;
9983 spec->adc_nids = alc262_adc_nids;
9984 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
9985 spec->capsrc_nids = alc262_capsrc_nids;
9986 spec->mixers[spec->num_mixers] = alc262_capture_mixer;
9991 spec->vmaster_nid = 0x0c;
9993 codec->patch_ops = alc_patch_ops;
9994 if (board_config == ALC262_AUTO)
9995 spec->init_hook = alc262_auto_init;
9996 #ifdef CONFIG_SND_HDA_POWER_SAVE
9997 if (!spec->loopback.amplist)
9998 spec->loopback.amplist = alc262_loopbacks;
10005 * ALC268 channel source setting (2 channel)
10007 #define ALC268_DIGOUT_NID ALC880_DIGOUT_NID
10008 #define alc268_modes alc260_modes
10010 static hda_nid_t alc268_dac_nids[2] = {
10015 static hda_nid_t alc268_adc_nids[2] = {
10020 static hda_nid_t alc268_adc_nids_alt[1] = {
10025 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10027 static struct snd_kcontrol_new alc268_base_mixer[] = {
10028 /* output mixer control */
10029 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10030 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10031 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10032 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10033 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10034 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10035 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10039 /* bind Beep switches of both NID 0x0f and 0x10 */
10040 static struct hda_bind_ctls alc268_bind_beep_sw = {
10041 .ops = &snd_hda_bind_sw,
10043 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10044 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10049 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10050 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10051 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10055 static struct hda_verb alc268_eapd_verbs[] = {
10056 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10057 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10061 /* Toshiba specific */
10062 #define alc268_toshiba_automute alc262_hippo_automute
10064 static struct hda_verb alc268_toshiba_verbs[] = {
10065 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10069 /* Acer specific */
10070 /* bind volumes of both NID 0x02 and 0x03 */
10071 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10072 .ops = &snd_hda_bind_vol,
10074 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10075 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10080 /* mute/unmute internal speaker according to the hp jack and mute state */
10081 static void alc268_acer_automute(struct hda_codec *codec, int force)
10083 struct alc_spec *spec = codec->spec;
10086 if (force || !spec->sense_updated) {
10087 unsigned int present;
10088 present = snd_hda_codec_read(codec, 0x14, 0,
10089 AC_VERB_GET_PIN_SENSE, 0);
10090 spec->jack_present = (present & 0x80000000) != 0;
10091 spec->sense_updated = 1;
10093 if (spec->jack_present)
10094 mute = HDA_AMP_MUTE; /* mute internal speaker */
10095 else /* unmute internal speaker if necessary */
10096 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10097 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10098 HDA_AMP_MUTE, mute);
10102 /* bind hp and internal speaker mute (with plug check) */
10103 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10104 struct snd_ctl_elem_value *ucontrol)
10106 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10107 long *valp = ucontrol->value.integer.value;
10110 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10112 valp[0] ? 0 : HDA_AMP_MUTE);
10113 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10115 valp[1] ? 0 : HDA_AMP_MUTE);
10117 alc268_acer_automute(codec, 0);
10121 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10122 /* output mixer control */
10123 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10125 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10126 .name = "Master Playback Switch",
10127 .info = snd_hda_mixer_amp_switch_info,
10128 .get = snd_hda_mixer_amp_switch_get,
10129 .put = alc268_acer_master_sw_put,
10130 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10132 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10133 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10134 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10138 static struct hda_verb alc268_acer_verbs[] = {
10139 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10140 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10141 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10142 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10143 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10144 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10146 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10150 /* unsolicited event for HP jack sensing */
10151 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10154 if ((res >> 26) != ALC880_HP_EVENT)
10156 alc268_toshiba_automute(codec);
10159 static void alc268_acer_unsol_event(struct hda_codec *codec,
10162 if ((res >> 26) != ALC880_HP_EVENT)
10164 alc268_acer_automute(codec, 1);
10167 static void alc268_acer_init_hook(struct hda_codec *codec)
10169 alc268_acer_automute(codec, 1);
10172 static struct snd_kcontrol_new alc268_dell_mixer[] = {
10173 /* output mixer control */
10174 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10175 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10176 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10177 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10178 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10179 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10183 static struct hda_verb alc268_dell_verbs[] = {
10184 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10185 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10186 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10190 /* mute/unmute internal speaker according to the hp jack and mute state */
10191 static void alc268_dell_automute(struct hda_codec *codec)
10193 unsigned int present;
10196 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
10197 if (present & 0x80000000)
10198 mute = HDA_AMP_MUTE;
10200 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
10201 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10202 HDA_AMP_MUTE, mute);
10205 static void alc268_dell_unsol_event(struct hda_codec *codec,
10208 if ((res >> 26) != ALC880_HP_EVENT)
10210 alc268_dell_automute(codec);
10213 #define alc268_dell_init_hook alc268_dell_automute
10215 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
10216 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10217 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10218 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10219 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10220 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10221 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
10222 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
10223 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10227 static struct hda_verb alc267_quanta_il1_verbs[] = {
10228 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10229 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
10233 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
10235 unsigned int present;
10237 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
10238 & AC_PINSENSE_PRESENCE;
10239 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
10240 present ? 0 : PIN_OUT);
10243 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
10245 unsigned int present;
10247 present = snd_hda_codec_read(codec, 0x18, 0,
10248 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10249 snd_hda_codec_write(codec, 0x23, 0,
10250 AC_VERB_SET_CONNECT_SEL,
10251 present ? 0x00 : 0x01);
10254 static void alc267_quanta_il1_automute(struct hda_codec *codec)
10256 alc267_quanta_il1_hp_automute(codec);
10257 alc267_quanta_il1_mic_automute(codec);
10260 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
10263 switch (res >> 26) {
10264 case ALC880_HP_EVENT:
10265 alc267_quanta_il1_hp_automute(codec);
10267 case ALC880_MIC_EVENT:
10268 alc267_quanta_il1_mic_automute(codec);
10274 * generic initialization of ADC, input mixers and output mixers
10276 static struct hda_verb alc268_base_init_verbs[] = {
10277 /* Unmute DAC0-1 and set vol = 0 */
10278 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10279 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10280 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10281 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10282 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10283 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10286 * Set up output mixers (0x0c - 0x0e)
10288 /* set vol=0 to output mixers */
10289 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10290 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10291 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10292 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
10294 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10295 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10297 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10298 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10299 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10300 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10301 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10302 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10303 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10304 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10306 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10307 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10308 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10309 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10310 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10311 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10312 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10314 /* set PCBEEP vol = 0, mute connections */
10315 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10316 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10317 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10319 /* Unmute Selector 23h,24h and set the default input to mic-in */
10321 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
10322 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10323 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
10324 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10330 * generic initialization of ADC, input mixers and output mixers
10332 static struct hda_verb alc268_volume_init_verbs[] = {
10333 /* set output DAC */
10334 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10335 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10336 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10337 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10339 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10340 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10341 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10342 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10343 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10345 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10346 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10347 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10348 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10349 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10351 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10352 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10353 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10354 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10356 /* set PCBEEP vol = 0, mute connections */
10357 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10358 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10359 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10364 #define alc268_mux_enum_info alc_mux_enum_info
10365 #define alc268_mux_enum_get alc_mux_enum_get
10366 #define alc268_mux_enum_put alc_mux_enum_put
10368 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
10369 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10370 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
10372 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10373 /* The multiple "Capture Source" controls confuse alsamixer
10374 * So call somewhat different..
10376 /* .name = "Capture Source", */
10377 .name = "Input Source",
10379 .info = alc268_mux_enum_info,
10380 .get = alc268_mux_enum_get,
10381 .put = alc268_mux_enum_put,
10386 static struct snd_kcontrol_new alc268_capture_mixer[] = {
10387 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10388 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
10389 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
10390 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
10392 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10393 /* The multiple "Capture Source" controls confuse alsamixer
10394 * So call somewhat different..
10396 /* .name = "Capture Source", */
10397 .name = "Input Source",
10399 .info = alc268_mux_enum_info,
10400 .get = alc268_mux_enum_get,
10401 .put = alc268_mux_enum_put,
10406 static struct hda_input_mux alc268_capture_source = {
10410 { "Front Mic", 0x1 },
10416 static struct hda_input_mux alc268_acer_capture_source = {
10420 { "Internal Mic", 0x6 },
10425 #ifdef CONFIG_SND_DEBUG
10426 static struct snd_kcontrol_new alc268_test_mixer[] = {
10427 /* Volume widgets */
10428 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10429 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10430 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
10431 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
10432 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
10433 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
10434 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
10435 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
10436 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
10437 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
10438 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
10439 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
10440 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
10441 /* The below appears problematic on some hardwares */
10442 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
10443 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10444 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
10445 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
10446 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
10448 /* Modes for retasking pin widgets */
10449 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
10450 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
10451 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
10452 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
10454 /* Controls for GPIO pins, assuming they are configured as outputs */
10455 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
10456 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
10457 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
10458 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
10460 /* Switches to allow the digital SPDIF output pin to be enabled.
10461 * The ALC268 does not have an SPDIF input.
10463 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
10465 /* A switch allowing EAPD to be enabled. Some laptops seem to use
10466 * this output to turn on an external amplifier.
10468 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
10469 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
10475 /* create input playback/capture controls for the given pin */
10476 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
10477 const char *ctlname, int idx)
10482 sprintf(name, "%s Playback Volume", ctlname);
10484 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
10485 HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
10489 } else if (nid == 0x15) {
10490 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
10491 HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
10497 sprintf(name, "%s Playback Switch", ctlname);
10498 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
10499 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
10505 /* add playback controls from the parsed DAC table */
10506 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
10507 const struct auto_pin_cfg *cfg)
10512 spec->multiout.num_dacs = 2; /* only use one dac */
10513 spec->multiout.dac_nids = spec->private_dac_nids;
10514 spec->multiout.dac_nids[0] = 2;
10515 spec->multiout.dac_nids[1] = 3;
10517 nid = cfg->line_out_pins[0];
10519 alc268_new_analog_output(spec, nid, "Front", 0);
10521 nid = cfg->speaker_pins[0];
10523 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10524 "Speaker Playback Volume",
10525 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10529 nid = cfg->hp_pins[0];
10531 alc268_new_analog_output(spec, nid, "Headphone", 0);
10533 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
10535 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10536 "Mono Playback Switch",
10537 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
10544 /* create playback/capture controls for input pins */
10545 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
10546 const struct auto_pin_cfg *cfg)
10548 struct hda_input_mux *imux = &spec->private_imux;
10551 for (i = 0; i < AUTO_PIN_LAST; i++) {
10552 switch(cfg->input_pins[i]) {
10554 idx1 = 0; /* Mic 1 */
10557 idx1 = 1; /* Mic 2 */
10560 idx1 = 2; /* Line In */
10567 idx1 = 6; /* digital mics */
10572 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
10573 imux->items[imux->num_items].index = idx1;
10579 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
10581 struct alc_spec *spec = codec->spec;
10582 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10583 hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10584 hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10585 unsigned int dac_vol1, dac_vol2;
10588 snd_hda_codec_write(codec, speaker_nid, 0,
10589 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
10590 snd_hda_codec_write(codec, 0x0f, 0,
10591 AC_VERB_SET_AMP_GAIN_MUTE,
10593 snd_hda_codec_write(codec, 0x10, 0,
10594 AC_VERB_SET_AMP_GAIN_MUTE,
10597 snd_hda_codec_write(codec, 0x0f, 0,
10598 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
10599 snd_hda_codec_write(codec, 0x10, 0,
10600 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
10603 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */
10604 if (line_nid == 0x14)
10605 dac_vol2 = AMP_OUT_ZERO;
10606 else if (line_nid == 0x15)
10607 dac_vol1 = AMP_OUT_ZERO;
10608 if (hp_nid == 0x14)
10609 dac_vol2 = AMP_OUT_ZERO;
10610 else if (hp_nid == 0x15)
10611 dac_vol1 = AMP_OUT_ZERO;
10612 if (line_nid != 0x16 || hp_nid != 0x16 ||
10613 spec->autocfg.line_out_pins[1] != 0x16 ||
10614 spec->autocfg.line_out_pins[2] != 0x16)
10615 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
10617 snd_hda_codec_write(codec, 0x02, 0,
10618 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
10619 snd_hda_codec_write(codec, 0x03, 0,
10620 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
10623 /* pcm configuration: identiacal with ALC880 */
10624 #define alc268_pcm_analog_playback alc880_pcm_analog_playback
10625 #define alc268_pcm_analog_capture alc880_pcm_analog_capture
10626 #define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
10627 #define alc268_pcm_digital_playback alc880_pcm_digital_playback
10630 * BIOS auto configuration
10632 static int alc268_parse_auto_config(struct hda_codec *codec)
10634 struct alc_spec *spec = codec->spec;
10636 static hda_nid_t alc268_ignore[] = { 0 };
10638 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10642 if (!spec->autocfg.line_outs)
10643 return 0; /* can't find valid BIOS pin config */
10645 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
10648 err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
10652 spec->multiout.max_channels = 2;
10654 /* digital only support output */
10655 if (spec->autocfg.dig_out_pin)
10656 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
10658 if (spec->kctl_alloc)
10659 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10661 if (spec->autocfg.speaker_pins[0] != 0x1d)
10662 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
10664 spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
10665 spec->num_mux_defs = 1;
10666 spec->input_mux = &spec->private_imux;
10668 err = alc_auto_add_mic_boost(codec);
10675 #define alc268_auto_init_multi_out alc882_auto_init_multi_out
10676 #define alc268_auto_init_hp_out alc882_auto_init_hp_out
10677 #define alc268_auto_init_analog_input alc882_auto_init_analog_input
10679 /* init callback for auto-configuration model -- overriding the default init */
10680 static void alc268_auto_init(struct hda_codec *codec)
10682 struct alc_spec *spec = codec->spec;
10683 alc268_auto_init_multi_out(codec);
10684 alc268_auto_init_hp_out(codec);
10685 alc268_auto_init_mono_speaker_out(codec);
10686 alc268_auto_init_analog_input(codec);
10687 if (spec->unsol_event)
10688 alc_sku_automute(codec);
10692 * configuration and preset
10694 static const char *alc268_models[ALC268_MODEL_LAST] = {
10695 [ALC267_QUANTA_IL1] = "quanta-il1",
10696 [ALC268_3ST] = "3stack",
10697 [ALC268_TOSHIBA] = "toshiba",
10698 [ALC268_ACER] = "acer",
10699 [ALC268_DELL] = "dell",
10700 [ALC268_ZEPTO] = "zepto",
10701 #ifdef CONFIG_SND_DEBUG
10702 [ALC268_TEST] = "test",
10704 [ALC268_AUTO] = "auto",
10707 static struct snd_pci_quirk alc268_cfg_tbl[] = {
10708 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
10709 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
10710 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
10711 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
10712 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
10713 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
10714 SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
10715 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
10716 SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
10717 SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
10718 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
10719 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
10720 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
10721 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
10725 static struct alc_config_preset alc268_presets[] = {
10726 [ALC267_QUANTA_IL1] = {
10727 .mixers = { alc267_quanta_il1_mixer },
10728 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10729 alc267_quanta_il1_verbs },
10730 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10731 .dac_nids = alc268_dac_nids,
10732 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10733 .adc_nids = alc268_adc_nids_alt,
10735 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10736 .channel_mode = alc268_modes,
10737 .input_mux = &alc268_capture_source,
10738 .unsol_event = alc267_quanta_il1_unsol_event,
10739 .init_hook = alc267_quanta_il1_automute,
10742 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10743 alc268_beep_mixer },
10744 .init_verbs = { alc268_base_init_verbs },
10745 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10746 .dac_nids = alc268_dac_nids,
10747 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10748 .adc_nids = alc268_adc_nids_alt,
10749 .capsrc_nids = alc268_capsrc_nids,
10751 .dig_out_nid = ALC268_DIGOUT_NID,
10752 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10753 .channel_mode = alc268_modes,
10754 .input_mux = &alc268_capture_source,
10756 [ALC268_TOSHIBA] = {
10757 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10758 alc268_beep_mixer },
10759 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10760 alc268_toshiba_verbs },
10761 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10762 .dac_nids = alc268_dac_nids,
10763 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10764 .adc_nids = alc268_adc_nids_alt,
10765 .capsrc_nids = alc268_capsrc_nids,
10767 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10768 .channel_mode = alc268_modes,
10769 .input_mux = &alc268_capture_source,
10770 .unsol_event = alc268_toshiba_unsol_event,
10771 .init_hook = alc268_toshiba_automute,
10774 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
10775 alc268_beep_mixer },
10776 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10777 alc268_acer_verbs },
10778 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10779 .dac_nids = alc268_dac_nids,
10780 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10781 .adc_nids = alc268_adc_nids_alt,
10782 .capsrc_nids = alc268_capsrc_nids,
10784 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10785 .channel_mode = alc268_modes,
10786 .input_mux = &alc268_acer_capture_source,
10787 .unsol_event = alc268_acer_unsol_event,
10788 .init_hook = alc268_acer_init_hook,
10791 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
10792 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10793 alc268_dell_verbs },
10794 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10795 .dac_nids = alc268_dac_nids,
10797 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10798 .channel_mode = alc268_modes,
10799 .unsol_event = alc268_dell_unsol_event,
10800 .init_hook = alc268_dell_init_hook,
10801 .input_mux = &alc268_capture_source,
10804 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10805 alc268_beep_mixer },
10806 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10807 alc268_toshiba_verbs },
10808 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10809 .dac_nids = alc268_dac_nids,
10810 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10811 .adc_nids = alc268_adc_nids_alt,
10812 .capsrc_nids = alc268_capsrc_nids,
10814 .dig_out_nid = ALC268_DIGOUT_NID,
10815 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10816 .channel_mode = alc268_modes,
10817 .input_mux = &alc268_capture_source,
10818 .unsol_event = alc268_toshiba_unsol_event,
10819 .init_hook = alc268_toshiba_automute
10821 #ifdef CONFIG_SND_DEBUG
10823 .mixers = { alc268_test_mixer, alc268_capture_mixer },
10824 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10825 alc268_volume_init_verbs },
10826 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10827 .dac_nids = alc268_dac_nids,
10828 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10829 .adc_nids = alc268_adc_nids_alt,
10830 .capsrc_nids = alc268_capsrc_nids,
10832 .dig_out_nid = ALC268_DIGOUT_NID,
10833 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10834 .channel_mode = alc268_modes,
10835 .input_mux = &alc268_capture_source,
10840 static int patch_alc268(struct hda_codec *codec)
10842 struct alc_spec *spec;
10846 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
10850 codec->spec = spec;
10852 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
10856 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
10857 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
10858 "trying auto-probe from BIOS...\n");
10859 board_config = ALC268_AUTO;
10862 if (board_config == ALC268_AUTO) {
10863 /* automatic parse from the BIOS config */
10864 err = alc268_parse_auto_config(codec);
10870 "hda_codec: Cannot set up configuration "
10871 "from BIOS. Using base mode...\n");
10872 board_config = ALC268_3ST;
10876 if (board_config != ALC268_AUTO)
10877 setup_preset(spec, &alc268_presets[board_config]);
10879 if (codec->vendor_id == 0x10ec0267) {
10880 spec->stream_name_analog = "ALC267 Analog";
10881 spec->stream_name_digital = "ALC267 Digital";
10883 spec->stream_name_analog = "ALC268 Analog";
10884 spec->stream_name_digital = "ALC268 Digital";
10887 spec->stream_analog_playback = &alc268_pcm_analog_playback;
10888 spec->stream_analog_capture = &alc268_pcm_analog_capture;
10889 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
10891 spec->stream_digital_playback = &alc268_pcm_digital_playback;
10893 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
10894 /* override the amp caps for beep generator */
10895 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
10896 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
10897 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
10898 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
10899 (0 << AC_AMPCAP_MUTE_SHIFT));
10901 if (!spec->adc_nids && spec->input_mux) {
10902 /* check whether NID 0x07 is valid */
10903 unsigned int wcap = get_wcaps(codec, 0x07);
10907 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10908 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
10909 spec->adc_nids = alc268_adc_nids_alt;
10910 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
10911 spec->mixers[spec->num_mixers] =
10912 alc268_capture_alt_mixer;
10913 spec->num_mixers++;
10915 spec->adc_nids = alc268_adc_nids;
10916 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
10917 spec->mixers[spec->num_mixers] =
10918 alc268_capture_mixer;
10919 spec->num_mixers++;
10921 spec->capsrc_nids = alc268_capsrc_nids;
10922 /* set default input source */
10923 for (i = 0; i < spec->num_adc_nids; i++)
10924 snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
10925 0, AC_VERB_SET_CONNECT_SEL,
10926 spec->input_mux->items[0].index);
10929 spec->vmaster_nid = 0x02;
10931 codec->patch_ops = alc_patch_ops;
10932 if (board_config == ALC268_AUTO)
10933 spec->init_hook = alc268_auto_init;
10939 * ALC269 channel source setting (2 channel)
10941 #define ALC269_DIGOUT_NID ALC880_DIGOUT_NID
10943 #define alc269_dac_nids alc260_dac_nids
10945 static hda_nid_t alc269_adc_nids[1] = {
10950 #define alc269_modes alc260_modes
10951 #define alc269_capture_source alc880_lg_lw_capture_source
10953 static struct snd_kcontrol_new alc269_base_mixer[] = {
10954 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10955 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10956 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10957 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10958 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10959 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10960 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10961 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10962 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10963 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10964 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10965 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10969 /* capture mixer elements */
10970 static struct snd_kcontrol_new alc269_capture_mixer[] = {
10971 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10972 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10974 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10975 /* The multiple "Capture Source" controls confuse alsamixer
10976 * So call somewhat different..
10978 /* .name = "Capture Source", */
10979 .name = "Input Source",
10981 .info = alc_mux_enum_info,
10982 .get = alc_mux_enum_get,
10983 .put = alc_mux_enum_put,
10989 * generic initialization of ADC, input mixers and output mixers
10991 static struct hda_verb alc269_init_verbs[] = {
10993 * Unmute ADC0 and set the default input to mic-in
10995 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10997 /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
10998 * analog-loopback mixer widget
10999 * Note: PASD motherboards uses the Line In 2 as the input for
11000 * front panel mic (mic 2)
11002 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11003 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11004 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11005 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11006 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11007 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11010 * Set up output mixers (0x0c - 0x0e)
11012 /* set vol=0 to output mixers */
11013 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11014 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11016 /* set up input amps for analog loopback */
11017 /* Amp Indices: DAC = 0, mixer = 1 */
11018 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11019 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11020 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11021 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11022 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11023 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11025 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11026 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11027 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11028 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11029 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11030 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11031 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11033 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11034 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11035 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11036 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11037 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11038 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11039 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11041 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11042 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11044 /* FIXME: use matrix-type input source selection */
11045 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
11046 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11047 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11048 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11049 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11050 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11053 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11054 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11058 /* add playback controls from the parsed DAC table */
11059 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
11060 const struct auto_pin_cfg *cfg)
11065 spec->multiout.num_dacs = 1; /* only use one dac */
11066 spec->multiout.dac_nids = spec->private_dac_nids;
11067 spec->multiout.dac_nids[0] = 2;
11069 nid = cfg->line_out_pins[0];
11071 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11072 "Front Playback Volume",
11073 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
11076 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11077 "Front Playback Switch",
11078 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
11083 nid = cfg->speaker_pins[0];
11085 if (!cfg->line_out_pins[0]) {
11086 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11087 "Speaker Playback Volume",
11088 HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
11094 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11095 "Speaker Playback Switch",
11096 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
11101 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11102 "Speaker Playback Switch",
11103 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
11109 nid = cfg->hp_pins[0];
11111 /* spec->multiout.hp_nid = 2; */
11112 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
11113 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11114 "Headphone Playback Volume",
11115 HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
11121 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11122 "Headphone Playback Switch",
11123 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
11128 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11129 "Headphone Playback Switch",
11130 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
11139 #define alc269_auto_create_analog_input_ctls \
11140 alc880_auto_create_analog_input_ctls
11142 #ifdef CONFIG_SND_HDA_POWER_SAVE
11143 #define alc269_loopbacks alc880_loopbacks
11146 /* pcm configuration: identiacal with ALC880 */
11147 #define alc269_pcm_analog_playback alc880_pcm_analog_playback
11148 #define alc269_pcm_analog_capture alc880_pcm_analog_capture
11149 #define alc269_pcm_digital_playback alc880_pcm_digital_playback
11150 #define alc269_pcm_digital_capture alc880_pcm_digital_capture
11153 * BIOS auto configuration
11155 static int alc269_parse_auto_config(struct hda_codec *codec)
11157 struct alc_spec *spec = codec->spec;
11159 static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
11161 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11166 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
11169 err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
11173 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11175 if (spec->autocfg.dig_out_pin)
11176 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
11178 if (spec->kctl_alloc)
11179 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11181 spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
11182 spec->num_mux_defs = 1;
11183 spec->input_mux = &spec->private_imux;
11185 err = alc_auto_add_mic_boost(codec);
11192 #define alc269_auto_init_multi_out alc882_auto_init_multi_out
11193 #define alc269_auto_init_hp_out alc882_auto_init_hp_out
11194 #define alc269_auto_init_analog_input alc882_auto_init_analog_input
11197 /* init callback for auto-configuration model -- overriding the default init */
11198 static void alc269_auto_init(struct hda_codec *codec)
11200 struct alc_spec *spec = codec->spec;
11201 alc269_auto_init_multi_out(codec);
11202 alc269_auto_init_hp_out(codec);
11203 alc269_auto_init_analog_input(codec);
11204 if (spec->unsol_event)
11205 alc_sku_automute(codec);
11209 * configuration and preset
11211 static const char *alc269_models[ALC269_MODEL_LAST] = {
11212 [ALC269_BASIC] = "basic",
11215 static struct snd_pci_quirk alc269_cfg_tbl[] = {
11219 static struct alc_config_preset alc269_presets[] = {
11221 .mixers = { alc269_base_mixer },
11222 .init_verbs = { alc269_init_verbs },
11223 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
11224 .dac_nids = alc269_dac_nids,
11226 .num_channel_mode = ARRAY_SIZE(alc269_modes),
11227 .channel_mode = alc269_modes,
11228 .input_mux = &alc269_capture_source,
11232 static int patch_alc269(struct hda_codec *codec)
11234 struct alc_spec *spec;
11238 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11242 codec->spec = spec;
11244 alc_fix_pll_init(codec, 0x20, 0x04, 15);
11246 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
11250 if (board_config < 0) {
11251 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
11252 "trying auto-probe from BIOS...\n");
11253 board_config = ALC269_AUTO;
11256 if (board_config == ALC269_AUTO) {
11257 /* automatic parse from the BIOS config */
11258 err = alc269_parse_auto_config(codec);
11264 "hda_codec: Cannot set up configuration "
11265 "from BIOS. Using base mode...\n");
11266 board_config = ALC269_BASIC;
11270 if (board_config != ALC269_AUTO)
11271 setup_preset(spec, &alc269_presets[board_config]);
11273 spec->stream_name_analog = "ALC269 Analog";
11274 spec->stream_analog_playback = &alc269_pcm_analog_playback;
11275 spec->stream_analog_capture = &alc269_pcm_analog_capture;
11277 spec->stream_name_digital = "ALC269 Digital";
11278 spec->stream_digital_playback = &alc269_pcm_digital_playback;
11279 spec->stream_digital_capture = &alc269_pcm_digital_capture;
11281 spec->adc_nids = alc269_adc_nids;
11282 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
11283 spec->mixers[spec->num_mixers] = alc269_capture_mixer;
11284 spec->num_mixers++;
11286 codec->patch_ops = alc_patch_ops;
11287 if (board_config == ALC269_AUTO)
11288 spec->init_hook = alc269_auto_init;
11289 #ifdef CONFIG_SND_HDA_POWER_SAVE
11290 if (!spec->loopback.amplist)
11291 spec->loopback.amplist = alc269_loopbacks;
11298 * ALC861 channel source setting (2/6 channel selection for 3-stack)
11302 * set the path ways for 2 channel output
11303 * need to set the codec line out and mic 1 pin widgets to inputs
11305 static struct hda_verb alc861_threestack_ch2_init[] = {
11306 /* set pin widget 1Ah (line in) for input */
11307 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11308 /* set pin widget 18h (mic1/2) for input, for mic also enable
11311 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11313 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
11315 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11316 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
11322 * need to set the codec line out and mic 1 pin widgets to outputs
11324 static struct hda_verb alc861_threestack_ch6_init[] = {
11325 /* set pin widget 1Ah (line in) for output (Back Surround)*/
11326 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11327 /* set pin widget 18h (mic1) for output (CLFE)*/
11328 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11330 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
11331 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
11333 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
11335 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11336 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
11341 static struct hda_channel_mode alc861_threestack_modes[2] = {
11342 { 2, alc861_threestack_ch2_init },
11343 { 6, alc861_threestack_ch6_init },
11345 /* Set mic1 as input and unmute the mixer */
11346 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
11347 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11348 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11351 /* Set mic1 as output and mute mixer */
11352 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
11353 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11354 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11358 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
11359 { 2, alc861_uniwill_m31_ch2_init },
11360 { 4, alc861_uniwill_m31_ch4_init },
11363 /* Set mic1 and line-in as input and unmute the mixer */
11364 static struct hda_verb alc861_asus_ch2_init[] = {
11365 /* set pin widget 1Ah (line in) for input */
11366 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11367 /* set pin widget 18h (mic1/2) for input, for mic also enable
11370 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11372 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
11374 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11375 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
11379 /* Set mic1 nad line-in as output and mute mixer */
11380 static struct hda_verb alc861_asus_ch6_init[] = {
11381 /* set pin widget 1Ah (line in) for output (Back Surround)*/
11382 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11383 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
11384 /* set pin widget 18h (mic1) for output (CLFE)*/
11385 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11386 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
11387 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
11388 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
11390 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
11392 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11393 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
11398 static struct hda_channel_mode alc861_asus_modes[2] = {
11399 { 2, alc861_asus_ch2_init },
11400 { 6, alc861_asus_ch6_init },
11405 static struct snd_kcontrol_new alc861_base_mixer[] = {
11406 /* output mixer control */
11407 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11408 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11409 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11410 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11411 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
11413 /*Input mixer control */
11414 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11415 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11416 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11417 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11418 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11419 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11420 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11421 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11422 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11423 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11425 /* Capture mixer control */
11426 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11427 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11429 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11430 .name = "Capture Source",
11432 .info = alc_mux_enum_info,
11433 .get = alc_mux_enum_get,
11434 .put = alc_mux_enum_put,
11439 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
11440 /* output mixer control */
11441 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11442 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11443 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11444 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11445 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
11447 /* Input mixer control */
11448 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11449 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11450 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11451 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11452 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11453 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11454 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11455 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11456 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11457 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11459 /* Capture mixer control */
11460 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11461 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11463 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11464 .name = "Capture Source",
11466 .info = alc_mux_enum_info,
11467 .get = alc_mux_enum_get,
11468 .put = alc_mux_enum_put,
11471 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11472 .name = "Channel Mode",
11473 .info = alc_ch_mode_info,
11474 .get = alc_ch_mode_get,
11475 .put = alc_ch_mode_put,
11476 .private_value = ARRAY_SIZE(alc861_threestack_modes),
11481 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
11482 /* output mixer control */
11483 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11484 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11485 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11487 /*Capture mixer control */
11488 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11489 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11491 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11492 .name = "Capture Source",
11494 .info = alc_mux_enum_info,
11495 .get = alc_mux_enum_get,
11496 .put = alc_mux_enum_put,
11502 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
11503 /* output mixer control */
11504 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11505 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11506 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11507 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11508 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
11510 /* Input mixer control */
11511 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11512 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11513 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11514 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11515 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11516 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11517 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11518 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11519 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11520 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11522 /* Capture mixer control */
11523 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11524 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11526 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11527 .name = "Capture Source",
11529 .info = alc_mux_enum_info,
11530 .get = alc_mux_enum_get,
11531 .put = alc_mux_enum_put,
11534 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11535 .name = "Channel Mode",
11536 .info = alc_ch_mode_info,
11537 .get = alc_ch_mode_get,
11538 .put = alc_ch_mode_put,
11539 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
11544 static struct snd_kcontrol_new alc861_asus_mixer[] = {
11545 /* output mixer control */
11546 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11547 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11548 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11549 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11550 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
11552 /* Input mixer control */
11553 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11554 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11555 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11556 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11557 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11558 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11559 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11560 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11561 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11562 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
11564 /* Capture mixer control */
11565 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11566 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11568 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11569 .name = "Capture Source",
11571 .info = alc_mux_enum_info,
11572 .get = alc_mux_enum_get,
11573 .put = alc_mux_enum_put,
11576 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11577 .name = "Channel Mode",
11578 .info = alc_ch_mode_info,
11579 .get = alc_ch_mode_get,
11580 .put = alc_ch_mode_put,
11581 .private_value = ARRAY_SIZE(alc861_asus_modes),
11586 /* additional mixer */
11587 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
11588 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11589 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11590 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
11591 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
11596 * generic initialization of ADC, input mixers and output mixers
11598 static struct hda_verb alc861_base_init_verbs[] = {
11600 * Unmute ADC0 and set the default input to mic-in
11602 /* port-A for surround (rear panel) */
11603 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11604 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
11605 /* port-B for mic-in (rear panel) with vref */
11606 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11607 /* port-C for line-in (rear panel) */
11608 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11609 /* port-D for Front */
11610 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11611 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11612 /* port-E for HP out (front panel) */
11613 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
11614 /* route front PCM to HP */
11615 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11616 /* port-F for mic-in (front panel) with vref */
11617 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11618 /* port-G for CLFE (rear panel) */
11619 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11620 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11621 /* port-H for side (rear panel) */
11622 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11623 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
11625 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11626 /* route front mic to ADC1*/
11627 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11628 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11630 /* Unmute DAC0~3 & spdif out*/
11631 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11632 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11633 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11634 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11635 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11637 /* Unmute Mixer 14 (mic) 1c (Line in)*/
11638 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11639 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11640 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11641 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11643 /* Unmute Stereo Mixer 15 */
11644 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11645 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11646 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11647 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11649 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11650 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11651 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11652 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11653 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11654 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11655 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11656 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11657 /* hp used DAC 3 (Front) */
11658 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11659 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11664 static struct hda_verb alc861_threestack_init_verbs[] = {
11666 * Unmute ADC0 and set the default input to mic-in
11668 /* port-A for surround (rear panel) */
11669 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11670 /* port-B for mic-in (rear panel) with vref */
11671 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11672 /* port-C for line-in (rear panel) */
11673 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11674 /* port-D for Front */
11675 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11676 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11677 /* port-E for HP out (front panel) */
11678 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
11679 /* route front PCM to HP */
11680 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11681 /* port-F for mic-in (front panel) with vref */
11682 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11683 /* port-G for CLFE (rear panel) */
11684 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11685 /* port-H for side (rear panel) */
11686 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11688 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11689 /* route front mic to ADC1*/
11690 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11691 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11692 /* Unmute DAC0~3 & spdif out*/
11693 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11694 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11695 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11696 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11697 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11699 /* Unmute Mixer 14 (mic) 1c (Line in)*/
11700 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11701 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11702 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11703 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11705 /* Unmute Stereo Mixer 15 */
11706 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11707 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11708 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11709 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11711 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11712 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11713 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11714 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11715 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11716 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11717 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11718 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11719 /* hp used DAC 3 (Front) */
11720 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11721 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11725 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
11727 * Unmute ADC0 and set the default input to mic-in
11729 /* port-A for surround (rear panel) */
11730 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11731 /* port-B for mic-in (rear panel) with vref */
11732 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11733 /* port-C for line-in (rear panel) */
11734 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11735 /* port-D for Front */
11736 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11737 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11738 /* port-E for HP out (front panel) */
11739 /* this has to be set to VREF80 */
11740 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11741 /* route front PCM to HP */
11742 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11743 /* port-F for mic-in (front panel) with vref */
11744 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11745 /* port-G for CLFE (rear panel) */
11746 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11747 /* port-H for side (rear panel) */
11748 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11750 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11751 /* route front mic to ADC1*/
11752 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11753 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11754 /* Unmute DAC0~3 & spdif out*/
11755 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11756 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11757 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11758 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11759 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11761 /* Unmute Mixer 14 (mic) 1c (Line in)*/
11762 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11763 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11764 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11765 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11767 /* Unmute Stereo Mixer 15 */
11768 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11769 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11770 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11771 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11773 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11774 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11775 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11776 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11777 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11778 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11779 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11780 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11781 /* hp used DAC 3 (Front) */
11782 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11783 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11787 static struct hda_verb alc861_asus_init_verbs[] = {
11789 * Unmute ADC0 and set the default input to mic-in
11791 /* port-A for surround (rear panel)
11792 * according to codec#0 this is the HP jack
11794 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
11795 /* route front PCM to HP */
11796 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
11797 /* port-B for mic-in (rear panel) with vref */
11798 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11799 /* port-C for line-in (rear panel) */
11800 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11801 /* port-D for Front */
11802 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11803 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11804 /* port-E for HP out (front panel) */
11805 /* this has to be set to VREF80 */
11806 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11807 /* route front PCM to HP */
11808 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11809 /* port-F for mic-in (front panel) with vref */
11810 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11811 /* port-G for CLFE (rear panel) */
11812 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11813 /* port-H for side (rear panel) */
11814 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11816 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11817 /* route front mic to ADC1*/
11818 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11819 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11820 /* Unmute DAC0~3 & spdif out*/
11821 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11822 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11823 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11824 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11825 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11826 /* Unmute Mixer 14 (mic) 1c (Line in)*/
11827 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11828 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11829 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11830 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11832 /* Unmute Stereo Mixer 15 */
11833 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11834 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11835 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11836 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11838 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11839 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11840 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11841 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11842 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11843 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11844 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11845 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11846 /* hp used DAC 3 (Front) */
11847 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11848 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11852 /* additional init verbs for ASUS laptops */
11853 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
11854 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
11855 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
11860 * generic initialization of ADC, input mixers and output mixers
11862 static struct hda_verb alc861_auto_init_verbs[] = {
11864 * Unmute ADC0 and set the default input to mic-in
11866 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
11867 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11869 /* Unmute DAC0~3 & spdif out*/
11870 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11871 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11872 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11873 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11874 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11876 /* Unmute Mixer 14 (mic) 1c (Line in)*/
11877 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11878 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11879 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11880 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11882 /* Unmute Stereo Mixer 15 */
11883 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11884 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11885 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11886 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
11888 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11889 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11890 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11891 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11892 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11893 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11894 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11895 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11897 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11898 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11899 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11900 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11901 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11902 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11903 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11904 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11906 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */
11911 static struct hda_verb alc861_toshiba_init_verbs[] = {
11912 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11917 /* toggle speaker-output according to the hp-jack state */
11918 static void alc861_toshiba_automute(struct hda_codec *codec)
11920 unsigned int present;
11922 present = snd_hda_codec_read(codec, 0x0f, 0,
11923 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11924 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
11925 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
11926 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
11927 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
11930 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
11933 if ((res >> 26) == ALC880_HP_EVENT)
11934 alc861_toshiba_automute(codec);
11937 /* pcm configuration: identiacal with ALC880 */
11938 #define alc861_pcm_analog_playback alc880_pcm_analog_playback
11939 #define alc861_pcm_analog_capture alc880_pcm_analog_capture
11940 #define alc861_pcm_digital_playback alc880_pcm_digital_playback
11941 #define alc861_pcm_digital_capture alc880_pcm_digital_capture
11944 #define ALC861_DIGOUT_NID 0x07
11946 static struct hda_channel_mode alc861_8ch_modes[1] = {
11950 static hda_nid_t alc861_dac_nids[4] = {
11951 /* front, surround, clfe, side */
11952 0x03, 0x06, 0x05, 0x04
11955 static hda_nid_t alc660_dac_nids[3] = {
11956 /* front, clfe, surround */
11960 static hda_nid_t alc861_adc_nids[1] = {
11965 static struct hda_input_mux alc861_capture_source = {
11969 { "Front Mic", 0x3 },
11976 /* fill in the dac_nids table from the parsed pin configuration */
11977 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
11978 const struct auto_pin_cfg *cfg)
11983 spec->multiout.dac_nids = spec->private_dac_nids;
11984 for (i = 0; i < cfg->line_outs; i++) {
11985 nid = cfg->line_out_pins[i];
11987 if (i >= ARRAY_SIZE(alc861_dac_nids))
11989 spec->multiout.dac_nids[i] = alc861_dac_nids[i];
11992 spec->multiout.num_dacs = cfg->line_outs;
11996 /* add playback controls from the parsed DAC table */
11997 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
11998 const struct auto_pin_cfg *cfg)
12001 static const char *chname[4] = {
12002 "Front", "Surround", NULL /*CLFE*/, "Side"
12007 for (i = 0; i < cfg->line_outs; i++) {
12008 nid = spec->multiout.dac_nids[i];
12013 err = add_control(spec, ALC_CTL_BIND_MUTE,
12014 "Center Playback Switch",
12015 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
12019 err = add_control(spec, ALC_CTL_BIND_MUTE,
12020 "LFE Playback Switch",
12021 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12026 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
12028 if (nid == alc861_dac_nids[idx])
12030 sprintf(name, "%s Playback Switch", chname[idx]);
12031 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
12032 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12041 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
12049 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
12051 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12052 "Headphone Playback Switch",
12053 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12056 spec->multiout.hp_nid = nid;
12061 /* create playback/capture controls for input pins */
12062 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
12063 const struct auto_pin_cfg *cfg)
12065 struct hda_input_mux *imux = &spec->private_imux;
12066 int i, err, idx, idx1;
12068 for (i = 0; i < AUTO_PIN_LAST; i++) {
12069 switch (cfg->input_pins[i]) {
12072 idx = 2; /* Line In */
12076 idx = 2; /* Line In */
12080 idx = 1; /* Mic In */
12084 idx = 1; /* Mic In */
12094 err = new_analog_input(spec, cfg->input_pins[i],
12095 auto_pin_cfg_labels[i], idx, 0x15);
12099 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
12100 imux->items[imux->num_items].index = idx1;
12106 static struct snd_kcontrol_new alc861_capture_mixer[] = {
12107 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12108 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12111 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12112 /* The multiple "Capture Source" controls confuse alsamixer
12113 * So call somewhat different..
12115 /* .name = "Capture Source", */
12116 .name = "Input Source",
12118 .info = alc_mux_enum_info,
12119 .get = alc_mux_enum_get,
12120 .put = alc_mux_enum_put,
12125 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
12127 int pin_type, int dac_idx)
12129 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
12131 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12135 static void alc861_auto_init_multi_out(struct hda_codec *codec)
12137 struct alc_spec *spec = codec->spec;
12140 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
12141 for (i = 0; i < spec->autocfg.line_outs; i++) {
12142 hda_nid_t nid = spec->autocfg.line_out_pins[i];
12143 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12145 alc861_auto_set_output_and_unmute(codec, nid, pin_type,
12146 spec->multiout.dac_nids[i]);
12150 static void alc861_auto_init_hp_out(struct hda_codec *codec)
12152 struct alc_spec *spec = codec->spec;
12155 pin = spec->autocfg.hp_pins[0];
12156 if (pin) /* connect to front */
12157 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
12158 spec->multiout.dac_nids[0]);
12159 pin = spec->autocfg.speaker_pins[0];
12161 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
12164 static void alc861_auto_init_analog_input(struct hda_codec *codec)
12166 struct alc_spec *spec = codec->spec;
12169 for (i = 0; i < AUTO_PIN_LAST; i++) {
12170 hda_nid_t nid = spec->autocfg.input_pins[i];
12171 if (nid >= 0x0c && nid <= 0x11) {
12172 snd_hda_codec_write(codec, nid, 0,
12173 AC_VERB_SET_PIN_WIDGET_CONTROL,
12174 i <= AUTO_PIN_FRONT_MIC ?
12175 PIN_VREF80 : PIN_IN);
12180 /* parse the BIOS configuration and set up the alc_spec */
12181 /* return 1 if successful, 0 if the proper config is not found,
12182 * or a negative error code
12184 static int alc861_parse_auto_config(struct hda_codec *codec)
12186 struct alc_spec *spec = codec->spec;
12188 static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
12190 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12194 if (!spec->autocfg.line_outs)
12195 return 0; /* can't find valid BIOS pin config */
12197 err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
12200 err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
12203 err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
12206 err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
12210 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12212 if (spec->autocfg.dig_out_pin)
12213 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
12215 if (spec->kctl_alloc)
12216 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12218 spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
12220 spec->num_mux_defs = 1;
12221 spec->input_mux = &spec->private_imux;
12223 spec->adc_nids = alc861_adc_nids;
12224 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
12225 spec->mixers[spec->num_mixers] = alc861_capture_mixer;
12226 spec->num_mixers++;
12231 /* additional initialization for auto-configuration model */
12232 static void alc861_auto_init(struct hda_codec *codec)
12234 struct alc_spec *spec = codec->spec;
12235 alc861_auto_init_multi_out(codec);
12236 alc861_auto_init_hp_out(codec);
12237 alc861_auto_init_analog_input(codec);
12238 if (spec->unsol_event)
12239 alc_sku_automute(codec);
12242 #ifdef CONFIG_SND_HDA_POWER_SAVE
12243 static struct hda_amp_list alc861_loopbacks[] = {
12244 { 0x15, HDA_INPUT, 0 },
12245 { 0x15, HDA_INPUT, 1 },
12246 { 0x15, HDA_INPUT, 2 },
12247 { 0x15, HDA_INPUT, 3 },
12254 * configuration and preset
12256 static const char *alc861_models[ALC861_MODEL_LAST] = {
12257 [ALC861_3ST] = "3stack",
12258 [ALC660_3ST] = "3stack-660",
12259 [ALC861_3ST_DIG] = "3stack-dig",
12260 [ALC861_6ST_DIG] = "6stack-dig",
12261 [ALC861_UNIWILL_M31] = "uniwill-m31",
12262 [ALC861_TOSHIBA] = "toshiba",
12263 [ALC861_ASUS] = "asus",
12264 [ALC861_ASUS_LAPTOP] = "asus-laptop",
12265 [ALC861_AUTO] = "auto",
12268 static struct snd_pci_quirk alc861_cfg_tbl[] = {
12269 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
12270 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
12271 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
12272 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
12273 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
12274 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
12275 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
12276 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
12277 * Any other models that need this preset?
12279 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
12280 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
12281 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
12282 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
12283 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
12284 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
12285 /* FIXME: the below seems conflict */
12286 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
12287 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
12288 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
12292 static struct alc_config_preset alc861_presets[] = {
12294 .mixers = { alc861_3ST_mixer },
12295 .init_verbs = { alc861_threestack_init_verbs },
12296 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12297 .dac_nids = alc861_dac_nids,
12298 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12299 .channel_mode = alc861_threestack_modes,
12301 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12302 .adc_nids = alc861_adc_nids,
12303 .input_mux = &alc861_capture_source,
12305 [ALC861_3ST_DIG] = {
12306 .mixers = { alc861_base_mixer },
12307 .init_verbs = { alc861_threestack_init_verbs },
12308 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12309 .dac_nids = alc861_dac_nids,
12310 .dig_out_nid = ALC861_DIGOUT_NID,
12311 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12312 .channel_mode = alc861_threestack_modes,
12314 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12315 .adc_nids = alc861_adc_nids,
12316 .input_mux = &alc861_capture_source,
12318 [ALC861_6ST_DIG] = {
12319 .mixers = { alc861_base_mixer },
12320 .init_verbs = { alc861_base_init_verbs },
12321 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12322 .dac_nids = alc861_dac_nids,
12323 .dig_out_nid = ALC861_DIGOUT_NID,
12324 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
12325 .channel_mode = alc861_8ch_modes,
12326 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12327 .adc_nids = alc861_adc_nids,
12328 .input_mux = &alc861_capture_source,
12331 .mixers = { alc861_3ST_mixer },
12332 .init_verbs = { alc861_threestack_init_verbs },
12333 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
12334 .dac_nids = alc660_dac_nids,
12335 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12336 .channel_mode = alc861_threestack_modes,
12338 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12339 .adc_nids = alc861_adc_nids,
12340 .input_mux = &alc861_capture_source,
12342 [ALC861_UNIWILL_M31] = {
12343 .mixers = { alc861_uniwill_m31_mixer },
12344 .init_verbs = { alc861_uniwill_m31_init_verbs },
12345 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12346 .dac_nids = alc861_dac_nids,
12347 .dig_out_nid = ALC861_DIGOUT_NID,
12348 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
12349 .channel_mode = alc861_uniwill_m31_modes,
12351 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12352 .adc_nids = alc861_adc_nids,
12353 .input_mux = &alc861_capture_source,
12355 [ALC861_TOSHIBA] = {
12356 .mixers = { alc861_toshiba_mixer },
12357 .init_verbs = { alc861_base_init_verbs,
12358 alc861_toshiba_init_verbs },
12359 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12360 .dac_nids = alc861_dac_nids,
12361 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
12362 .channel_mode = alc883_3ST_2ch_modes,
12363 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12364 .adc_nids = alc861_adc_nids,
12365 .input_mux = &alc861_capture_source,
12366 .unsol_event = alc861_toshiba_unsol_event,
12367 .init_hook = alc861_toshiba_automute,
12370 .mixers = { alc861_asus_mixer },
12371 .init_verbs = { alc861_asus_init_verbs },
12372 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12373 .dac_nids = alc861_dac_nids,
12374 .dig_out_nid = ALC861_DIGOUT_NID,
12375 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
12376 .channel_mode = alc861_asus_modes,
12379 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12380 .adc_nids = alc861_adc_nids,
12381 .input_mux = &alc861_capture_source,
12383 [ALC861_ASUS_LAPTOP] = {
12384 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
12385 .init_verbs = { alc861_asus_init_verbs,
12386 alc861_asus_laptop_init_verbs },
12387 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12388 .dac_nids = alc861_dac_nids,
12389 .dig_out_nid = ALC861_DIGOUT_NID,
12390 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
12391 .channel_mode = alc883_3ST_2ch_modes,
12393 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12394 .adc_nids = alc861_adc_nids,
12395 .input_mux = &alc861_capture_source,
12400 static int patch_alc861(struct hda_codec *codec)
12402 struct alc_spec *spec;
12406 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12410 codec->spec = spec;
12412 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
12416 if (board_config < 0) {
12417 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
12418 "trying auto-probe from BIOS...\n");
12419 board_config = ALC861_AUTO;
12422 if (board_config == ALC861_AUTO) {
12423 /* automatic parse from the BIOS config */
12424 err = alc861_parse_auto_config(codec);
12430 "hda_codec: Cannot set up configuration "
12431 "from BIOS. Using base mode...\n");
12432 board_config = ALC861_3ST_DIG;
12436 if (board_config != ALC861_AUTO)
12437 setup_preset(spec, &alc861_presets[board_config]);
12439 spec->stream_name_analog = "ALC861 Analog";
12440 spec->stream_analog_playback = &alc861_pcm_analog_playback;
12441 spec->stream_analog_capture = &alc861_pcm_analog_capture;
12443 spec->stream_name_digital = "ALC861 Digital";
12444 spec->stream_digital_playback = &alc861_pcm_digital_playback;
12445 spec->stream_digital_capture = &alc861_pcm_digital_capture;
12447 spec->vmaster_nid = 0x03;
12449 codec->patch_ops = alc_patch_ops;
12450 if (board_config == ALC861_AUTO)
12451 spec->init_hook = alc861_auto_init;
12452 #ifdef CONFIG_SND_HDA_POWER_SAVE
12453 if (!spec->loopback.amplist)
12454 spec->loopback.amplist = alc861_loopbacks;
12461 * ALC861-VD support
12465 * In addition, an independent DAC
12467 #define ALC861VD_DIGOUT_NID 0x06
12469 static hda_nid_t alc861vd_dac_nids[4] = {
12470 /* front, surr, clfe, side surr */
12471 0x02, 0x03, 0x04, 0x05
12474 /* dac_nids for ALC660vd are in a different order - according to
12475 * Realtek's driver.
12476 * This should probably tesult in a different mixer for 6stack models
12477 * of ALC660vd codecs, but for now there is only 3stack mixer
12478 * - and it is the same as in 861vd.
12479 * adc_nids in ALC660vd are (is) the same as in 861vd
12481 static hda_nid_t alc660vd_dac_nids[3] = {
12482 /* front, rear, clfe, rear_surr */
12486 static hda_nid_t alc861vd_adc_nids[1] = {
12491 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
12494 /* FIXME: should be a matrix-type input source selection */
12495 static struct hda_input_mux alc861vd_capture_source = {
12499 { "Front Mic", 0x1 },
12505 static struct hda_input_mux alc861vd_dallas_capture_source = {
12508 { "Ext Mic", 0x0 },
12509 { "Int Mic", 0x1 },
12513 static struct hda_input_mux alc861vd_hp_capture_source = {
12516 { "Front Mic", 0x0 },
12517 { "ATAPI Mic", 0x1 },
12521 #define alc861vd_mux_enum_info alc_mux_enum_info
12522 #define alc861vd_mux_enum_get alc_mux_enum_get
12523 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
12524 #define alc861vd_mux_enum_put alc882_mux_enum_put
12529 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
12536 static struct hda_verb alc861vd_6stack_ch6_init[] = {
12537 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12538 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12539 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12540 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12547 static struct hda_verb alc861vd_6stack_ch8_init[] = {
12548 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12549 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12550 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12551 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12555 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
12556 { 6, alc861vd_6stack_ch6_init },
12557 { 8, alc861vd_6stack_ch8_init },
12560 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
12562 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12563 .name = "Channel Mode",
12564 .info = alc_ch_mode_info,
12565 .get = alc_ch_mode_get,
12566 .put = alc_ch_mode_put,
12571 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
12572 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
12573 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
12576 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12577 /* The multiple "Capture Source" controls confuse alsamixer
12578 * So call somewhat different..
12580 /* .name = "Capture Source", */
12581 .name = "Input Source",
12583 .info = alc861vd_mux_enum_info,
12584 .get = alc861vd_mux_enum_get,
12585 .put = alc861vd_mux_enum_put,
12590 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
12591 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
12593 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
12594 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12595 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12597 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12598 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
12600 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
12602 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
12604 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12605 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
12607 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
12608 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
12610 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12612 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12613 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12614 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12616 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12617 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12618 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12620 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12621 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12623 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12624 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12626 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12627 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12632 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
12633 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12634 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12636 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12638 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12639 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12640 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12642 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12643 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12644 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12646 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12647 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12649 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12650 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12652 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12653 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12658 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
12659 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12660 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
12661 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12663 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12665 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12666 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12667 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12669 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12670 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12671 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12673 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12674 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12679 /* Pin assignment: Speaker=0x14, HP = 0x15,
12680 * Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
12682 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
12683 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12684 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
12685 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12686 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12687 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12688 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12689 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12690 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12691 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12692 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12693 HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
12694 HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
12698 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
12699 * Front Mic=0x18, ATAPI Mic = 0x19,
12701 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
12702 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12703 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12704 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12705 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12706 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12707 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12708 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12709 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12715 * generic initialization of ADC, input mixers and output mixers
12717 static struct hda_verb alc861vd_volume_init_verbs[] = {
12719 * Unmute ADC0 and set the default input to mic-in
12721 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12722 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12724 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
12725 * the analog-loopback mixer widget
12727 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12728 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12729 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12730 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12731 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12732 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12734 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
12735 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12736 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12737 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12738 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
12741 * Set up output mixers (0x02 - 0x05)
12743 /* set vol=0 to output mixers */
12744 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12745 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12746 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12747 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12749 /* set up input amps for analog loopback */
12750 /* Amp Indices: DAC = 0, mixer = 1 */
12751 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12752 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12753 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12754 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12755 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12756 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12757 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12758 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12764 * 3-stack pin configuration:
12765 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
12767 static struct hda_verb alc861vd_3stack_init_verbs[] = {
12769 * Set pin mode and muting
12771 /* set front pin widgets 0x14 for output */
12772 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12773 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12774 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12776 /* Mic (rear) pin: input vref at 80% */
12777 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12778 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12779 /* Front Mic pin: input vref at 80% */
12780 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12781 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12782 /* Line In pin: input */
12783 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12784 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12785 /* Line-2 In: Headphone output (output 0 - 0x0c) */
12786 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12787 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12788 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12789 /* CD pin widget for input */
12790 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12796 * 6-stack pin configuration:
12798 static struct hda_verb alc861vd_6stack_init_verbs[] = {
12800 * Set pin mode and muting
12802 /* set front pin widgets 0x14 for output */
12803 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12804 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12805 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12807 /* Rear Pin: output 1 (0x0d) */
12808 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12809 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12810 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12811 /* CLFE Pin: output 2 (0x0e) */
12812 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12813 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12814 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
12815 /* Side Pin: output 3 (0x0f) */
12816 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12817 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12818 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
12820 /* Mic (rear) pin: input vref at 80% */
12821 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12822 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12823 /* Front Mic pin: input vref at 80% */
12824 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12825 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12826 /* Line In pin: input */
12827 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12828 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12829 /* Line-2 In: Headphone output (output 0 - 0x0c) */
12830 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12831 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12832 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12833 /* CD pin widget for input */
12834 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12839 static struct hda_verb alc861vd_eapd_verbs[] = {
12840 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12844 static struct hda_verb alc660vd_eapd_verbs[] = {
12845 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12846 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12850 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
12851 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12852 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12853 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12854 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12855 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12859 /* toggle speaker-output according to the hp-jack state */
12860 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
12862 unsigned int present;
12863 unsigned char bits;
12865 present = snd_hda_codec_read(codec, 0x1b, 0,
12866 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12867 bits = present ? HDA_AMP_MUTE : 0;
12868 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12869 HDA_AMP_MUTE, bits);
12872 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
12874 unsigned int present;
12875 unsigned char bits;
12877 present = snd_hda_codec_read(codec, 0x18, 0,
12878 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12879 bits = present ? HDA_AMP_MUTE : 0;
12880 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
12881 HDA_AMP_MUTE, bits);
12884 static void alc861vd_lenovo_automute(struct hda_codec *codec)
12886 alc861vd_lenovo_hp_automute(codec);
12887 alc861vd_lenovo_mic_automute(codec);
12890 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
12893 switch (res >> 26) {
12894 case ALC880_HP_EVENT:
12895 alc861vd_lenovo_hp_automute(codec);
12897 case ALC880_MIC_EVENT:
12898 alc861vd_lenovo_mic_automute(codec);
12903 static struct hda_verb alc861vd_dallas_verbs[] = {
12904 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12905 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12906 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12907 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12909 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12910 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12911 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12912 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12913 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12914 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12915 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12916 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12918 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12919 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12920 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12921 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12922 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12923 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12924 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12925 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12927 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
12928 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12929 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
12930 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12931 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12932 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12933 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12934 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12936 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12937 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12938 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12939 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12941 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12942 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12943 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12948 /* toggle speaker-output according to the hp-jack state */
12949 static void alc861vd_dallas_automute(struct hda_codec *codec)
12951 unsigned int present;
12953 present = snd_hda_codec_read(codec, 0x15, 0,
12954 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12955 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12956 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
12959 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
12961 if ((res >> 26) == ALC880_HP_EVENT)
12962 alc861vd_dallas_automute(codec);
12965 #ifdef CONFIG_SND_HDA_POWER_SAVE
12966 #define alc861vd_loopbacks alc880_loopbacks
12969 /* pcm configuration: identiacal with ALC880 */
12970 #define alc861vd_pcm_analog_playback alc880_pcm_analog_playback
12971 #define alc861vd_pcm_analog_capture alc880_pcm_analog_capture
12972 #define alc861vd_pcm_digital_playback alc880_pcm_digital_playback
12973 #define alc861vd_pcm_digital_capture alc880_pcm_digital_capture
12976 * configuration and preset
12978 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
12979 [ALC660VD_3ST] = "3stack-660",
12980 [ALC660VD_3ST_DIG] = "3stack-660-digout",
12981 [ALC861VD_3ST] = "3stack",
12982 [ALC861VD_3ST_DIG] = "3stack-digout",
12983 [ALC861VD_6ST_DIG] = "6stack-digout",
12984 [ALC861VD_LENOVO] = "lenovo",
12985 [ALC861VD_DALLAS] = "dallas",
12986 [ALC861VD_HP] = "hp",
12987 [ALC861VD_AUTO] = "auto",
12990 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
12991 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
12992 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
12993 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
12994 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
12995 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
12996 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
12997 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
12998 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
12999 SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
13000 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
13001 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
13002 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
13003 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
13004 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
13005 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
13009 static struct alc_config_preset alc861vd_presets[] = {
13011 .mixers = { alc861vd_3st_mixer },
13012 .init_verbs = { alc861vd_volume_init_verbs,
13013 alc861vd_3stack_init_verbs },
13014 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13015 .dac_nids = alc660vd_dac_nids,
13016 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13017 .channel_mode = alc861vd_3stack_2ch_modes,
13018 .input_mux = &alc861vd_capture_source,
13020 [ALC660VD_3ST_DIG] = {
13021 .mixers = { alc861vd_3st_mixer },
13022 .init_verbs = { alc861vd_volume_init_verbs,
13023 alc861vd_3stack_init_verbs },
13024 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13025 .dac_nids = alc660vd_dac_nids,
13026 .dig_out_nid = ALC861VD_DIGOUT_NID,
13027 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13028 .channel_mode = alc861vd_3stack_2ch_modes,
13029 .input_mux = &alc861vd_capture_source,
13032 .mixers = { alc861vd_3st_mixer },
13033 .init_verbs = { alc861vd_volume_init_verbs,
13034 alc861vd_3stack_init_verbs },
13035 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13036 .dac_nids = alc861vd_dac_nids,
13037 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13038 .channel_mode = alc861vd_3stack_2ch_modes,
13039 .input_mux = &alc861vd_capture_source,
13041 [ALC861VD_3ST_DIG] = {
13042 .mixers = { alc861vd_3st_mixer },
13043 .init_verbs = { alc861vd_volume_init_verbs,
13044 alc861vd_3stack_init_verbs },
13045 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13046 .dac_nids = alc861vd_dac_nids,
13047 .dig_out_nid = ALC861VD_DIGOUT_NID,
13048 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13049 .channel_mode = alc861vd_3stack_2ch_modes,
13050 .input_mux = &alc861vd_capture_source,
13052 [ALC861VD_6ST_DIG] = {
13053 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
13054 .init_verbs = { alc861vd_volume_init_verbs,
13055 alc861vd_6stack_init_verbs },
13056 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13057 .dac_nids = alc861vd_dac_nids,
13058 .dig_out_nid = ALC861VD_DIGOUT_NID,
13059 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
13060 .channel_mode = alc861vd_6stack_modes,
13061 .input_mux = &alc861vd_capture_source,
13063 [ALC861VD_LENOVO] = {
13064 .mixers = { alc861vd_lenovo_mixer },
13065 .init_verbs = { alc861vd_volume_init_verbs,
13066 alc861vd_3stack_init_verbs,
13067 alc861vd_eapd_verbs,
13068 alc861vd_lenovo_unsol_verbs },
13069 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13070 .dac_nids = alc660vd_dac_nids,
13071 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13072 .channel_mode = alc861vd_3stack_2ch_modes,
13073 .input_mux = &alc861vd_capture_source,
13074 .unsol_event = alc861vd_lenovo_unsol_event,
13075 .init_hook = alc861vd_lenovo_automute,
13077 [ALC861VD_DALLAS] = {
13078 .mixers = { alc861vd_dallas_mixer },
13079 .init_verbs = { alc861vd_dallas_verbs },
13080 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13081 .dac_nids = alc861vd_dac_nids,
13082 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13083 .channel_mode = alc861vd_3stack_2ch_modes,
13084 .input_mux = &alc861vd_dallas_capture_source,
13085 .unsol_event = alc861vd_dallas_unsol_event,
13086 .init_hook = alc861vd_dallas_automute,
13089 .mixers = { alc861vd_hp_mixer },
13090 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
13091 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13092 .dac_nids = alc861vd_dac_nids,
13093 .dig_out_nid = ALC861VD_DIGOUT_NID,
13094 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13095 .channel_mode = alc861vd_3stack_2ch_modes,
13096 .input_mux = &alc861vd_hp_capture_source,
13097 .unsol_event = alc861vd_dallas_unsol_event,
13098 .init_hook = alc861vd_dallas_automute,
13103 * BIOS auto configuration
13105 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
13106 hda_nid_t nid, int pin_type, int dac_idx)
13108 alc_set_pin_output(codec, nid, pin_type);
13111 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
13113 struct alc_spec *spec = codec->spec;
13116 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
13117 for (i = 0; i <= HDA_SIDE; i++) {
13118 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13119 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13121 alc861vd_auto_set_output_and_unmute(codec, nid,
13127 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
13129 struct alc_spec *spec = codec->spec;
13132 pin = spec->autocfg.hp_pins[0];
13133 if (pin) /* connect to front and use dac 0 */
13134 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
13135 pin = spec->autocfg.speaker_pins[0];
13137 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13140 #define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid)
13141 #define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID
13143 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
13145 struct alc_spec *spec = codec->spec;
13148 for (i = 0; i < AUTO_PIN_LAST; i++) {
13149 hda_nid_t nid = spec->autocfg.input_pins[i];
13150 if (alc861vd_is_input_pin(nid)) {
13151 snd_hda_codec_write(codec, nid, 0,
13152 AC_VERB_SET_PIN_WIDGET_CONTROL,
13153 i <= AUTO_PIN_FRONT_MIC ?
13154 PIN_VREF80 : PIN_IN);
13155 if (nid != ALC861VD_PIN_CD_NID)
13156 snd_hda_codec_write(codec, nid, 0,
13157 AC_VERB_SET_AMP_GAIN_MUTE,
13163 #define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02)
13164 #define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c)
13166 /* add playback controls from the parsed DAC table */
13167 /* Based on ALC880 version. But ALC861VD has separate,
13168 * different NIDs for mute/unmute switch and volume control */
13169 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
13170 const struct auto_pin_cfg *cfg)
13173 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
13174 hda_nid_t nid_v, nid_s;
13177 for (i = 0; i < cfg->line_outs; i++) {
13178 if (!spec->multiout.dac_nids[i])
13180 nid_v = alc861vd_idx_to_mixer_vol(
13182 spec->multiout.dac_nids[i]));
13183 nid_s = alc861vd_idx_to_mixer_switch(
13185 spec->multiout.dac_nids[i]));
13189 err = add_control(spec, ALC_CTL_WIDGET_VOL,
13190 "Center Playback Volume",
13191 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
13195 err = add_control(spec, ALC_CTL_WIDGET_VOL,
13196 "LFE Playback Volume",
13197 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
13201 err = add_control(spec, ALC_CTL_BIND_MUTE,
13202 "Center Playback Switch",
13203 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
13207 err = add_control(spec, ALC_CTL_BIND_MUTE,
13208 "LFE Playback Switch",
13209 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
13214 sprintf(name, "%s Playback Volume", chname[i]);
13215 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13216 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
13220 sprintf(name, "%s Playback Switch", chname[i]);
13221 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13222 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
13231 /* add playback controls for speaker and HP outputs */
13232 /* Based on ALC880 version. But ALC861VD has separate,
13233 * different NIDs for mute/unmute switch and volume control */
13234 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
13235 hda_nid_t pin, const char *pfx)
13237 hda_nid_t nid_v, nid_s;
13244 if (alc880_is_fixed_pin(pin)) {
13245 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
13246 /* specify the DAC as the extra output */
13247 if (!spec->multiout.hp_nid)
13248 spec->multiout.hp_nid = nid_v;
13250 spec->multiout.extra_out_nid[0] = nid_v;
13251 /* control HP volume/switch on the output mixer amp */
13252 nid_v = alc861vd_idx_to_mixer_vol(
13253 alc880_fixed_pin_idx(pin));
13254 nid_s = alc861vd_idx_to_mixer_switch(
13255 alc880_fixed_pin_idx(pin));
13257 sprintf(name, "%s Playback Volume", pfx);
13258 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13259 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
13262 sprintf(name, "%s Playback Switch", pfx);
13263 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13264 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
13267 } else if (alc880_is_multi_pin(pin)) {
13268 /* set manual connection */
13269 /* we have only a switch on HP-out PIN */
13270 sprintf(name, "%s Playback Switch", pfx);
13271 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
13272 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
13279 /* parse the BIOS configuration and set up the alc_spec
13280 * return 1 if successful, 0 if the proper config is not found,
13281 * or a negative error code
13282 * Based on ALC880 version - had to change it to override
13283 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
13284 static int alc861vd_parse_auto_config(struct hda_codec *codec)
13286 struct alc_spec *spec = codec->spec;
13288 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
13290 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13294 if (!spec->autocfg.line_outs)
13295 return 0; /* can't find valid BIOS pin config */
13297 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
13300 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
13303 err = alc861vd_auto_create_extra_out(spec,
13304 spec->autocfg.speaker_pins[0],
13308 err = alc861vd_auto_create_extra_out(spec,
13309 spec->autocfg.hp_pins[0],
13313 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
13317 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13319 if (spec->autocfg.dig_out_pin)
13320 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
13322 if (spec->kctl_alloc)
13323 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13325 spec->init_verbs[spec->num_init_verbs++]
13326 = alc861vd_volume_init_verbs;
13328 spec->num_mux_defs = 1;
13329 spec->input_mux = &spec->private_imux;
13331 err = alc_auto_add_mic_boost(codec);
13338 /* additional initialization for auto-configuration model */
13339 static void alc861vd_auto_init(struct hda_codec *codec)
13341 struct alc_spec *spec = codec->spec;
13342 alc861vd_auto_init_multi_out(codec);
13343 alc861vd_auto_init_hp_out(codec);
13344 alc861vd_auto_init_analog_input(codec);
13345 if (spec->unsol_event)
13346 alc_sku_automute(codec);
13349 static int patch_alc861vd(struct hda_codec *codec)
13351 struct alc_spec *spec;
13352 int err, board_config;
13354 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13358 codec->spec = spec;
13360 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
13364 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
13365 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
13366 "ALC861VD, trying auto-probe from BIOS...\n");
13367 board_config = ALC861VD_AUTO;
13370 if (board_config == ALC861VD_AUTO) {
13371 /* automatic parse from the BIOS config */
13372 err = alc861vd_parse_auto_config(codec);
13378 "hda_codec: Cannot set up configuration "
13379 "from BIOS. Using base mode...\n");
13380 board_config = ALC861VD_3ST;
13384 if (board_config != ALC861VD_AUTO)
13385 setup_preset(spec, &alc861vd_presets[board_config]);
13387 if (codec->vendor_id == 0x10ec0660) {
13388 spec->stream_name_analog = "ALC660-VD Analog";
13389 spec->stream_name_digital = "ALC660-VD Digital";
13390 /* always turn on EAPD */
13391 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
13393 spec->stream_name_analog = "ALC861VD Analog";
13394 spec->stream_name_digital = "ALC861VD Digital";
13397 spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
13398 spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
13400 spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
13401 spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
13403 spec->adc_nids = alc861vd_adc_nids;
13404 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
13405 spec->capsrc_nids = alc861vd_capsrc_nids;
13407 spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
13408 spec->num_mixers++;
13410 spec->vmaster_nid = 0x02;
13412 codec->patch_ops = alc_patch_ops;
13414 if (board_config == ALC861VD_AUTO)
13415 spec->init_hook = alc861vd_auto_init;
13416 #ifdef CONFIG_SND_HDA_POWER_SAVE
13417 if (!spec->loopback.amplist)
13418 spec->loopback.amplist = alc861vd_loopbacks;
13427 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
13428 * configuration. Each pin widget can choose any input DACs and a mixer.
13429 * Each ADC is connected from a mixer of all inputs. This makes possible
13430 * 6-channel independent captures.
13432 * In addition, an independent DAC for the multi-playback (not used in this
13435 #define ALC662_DIGOUT_NID 0x06
13436 #define ALC662_DIGIN_NID 0x0a
13438 static hda_nid_t alc662_dac_nids[4] = {
13439 /* front, rear, clfe, rear_surr */
13443 static hda_nid_t alc662_adc_nids[1] = {
13448 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
13451 /* FIXME: should be a matrix-type input source selection */
13452 static struct hda_input_mux alc662_capture_source = {
13456 { "Front Mic", 0x1 },
13462 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
13470 static struct hda_input_mux alc662_eeepc_capture_source = {
13478 static struct hda_input_mux alc663_capture_source = {
13482 { "Front Mic", 0x1 },
13487 static struct hda_input_mux alc663_m51va_capture_source = {
13490 { "Ext-Mic", 0x0 },
13495 #define alc662_mux_enum_info alc_mux_enum_info
13496 #define alc662_mux_enum_get alc_mux_enum_get
13497 #define alc662_mux_enum_put alc882_mux_enum_put
13502 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
13509 static struct hda_verb alc662_3ST_ch2_init[] = {
13510 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
13511 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
13512 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
13513 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
13520 static struct hda_verb alc662_3ST_ch6_init[] = {
13521 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13522 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
13523 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
13524 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13525 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
13526 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
13530 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
13531 { 2, alc662_3ST_ch2_init },
13532 { 6, alc662_3ST_ch6_init },
13538 static struct hda_verb alc662_sixstack_ch6_init[] = {
13539 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13540 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13541 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13548 static struct hda_verb alc662_sixstack_ch8_init[] = {
13549 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13550 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13551 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13555 static struct hda_channel_mode alc662_5stack_modes[2] = {
13556 { 2, alc662_sixstack_ch6_init },
13557 { 6, alc662_sixstack_ch8_init },
13560 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13561 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13564 static struct snd_kcontrol_new alc662_base_mixer[] = {
13565 /* output mixer control */
13566 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13567 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13568 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13569 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
13570 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13571 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13572 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
13573 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
13574 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13576 /*Input mixer control */
13577 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
13578 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
13579 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
13580 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
13581 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
13582 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
13583 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
13584 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
13588 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
13589 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13590 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13591 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13592 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13593 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13594 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13595 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13596 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13597 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13598 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13599 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13600 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13601 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13605 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
13606 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13607 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13608 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13609 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
13610 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13611 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13612 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
13613 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
13614 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13615 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13616 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13617 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13618 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13619 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13620 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13621 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13622 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13623 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13624 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13628 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
13629 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13630 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
13631 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13632 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
13633 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13634 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13635 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13636 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13637 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13641 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
13642 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13644 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13645 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13647 HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
13648 HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13649 HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13651 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
13652 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13653 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13657 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
13658 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13659 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13660 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13661 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
13662 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13663 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13664 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
13665 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
13666 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13667 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
13668 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13669 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13670 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13671 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13675 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
13676 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13677 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13678 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13679 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13680 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13681 HDA_CODEC_MUTE("DMic Playback Switch", 0x23, 0x9, HDA_INPUT),
13685 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
13686 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13687 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13688 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13689 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13690 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13692 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13693 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13694 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13695 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13699 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
13700 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13701 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13702 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13704 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13705 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13706 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13707 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13708 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13709 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13713 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
13715 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13716 .name = "Channel Mode",
13717 .info = alc_ch_mode_info,
13718 .get = alc_ch_mode_get,
13719 .put = alc_ch_mode_put,
13724 static struct hda_verb alc662_init_verbs[] = {
13725 /* ADC: mute amp left and right */
13726 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13727 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13728 /* Front mixer: unmute input/output amp left and right (volume = 0) */
13730 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13731 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13732 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13733 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13734 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13736 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13737 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13738 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13739 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13740 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13741 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13743 /* Front Pin: output 0 (0x0c) */
13744 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13745 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13747 /* Rear Pin: output 1 (0x0d) */
13748 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13749 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13751 /* CLFE Pin: output 2 (0x0e) */
13752 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13753 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13755 /* Mic (rear) pin: input vref at 80% */
13756 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13757 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13758 /* Front Mic pin: input vref at 80% */
13759 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13760 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13761 /* Line In pin: input */
13762 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13763 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13764 /* Line-2 In: Headphone output (output 0 - 0x0c) */
13765 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13766 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13767 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13768 /* CD pin widget for input */
13769 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13771 /* FIXME: use matrix-type input source selection */
13772 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
13774 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13775 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13776 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13777 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13779 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13780 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13781 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13782 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13784 /* always trun on EAPD */
13785 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13786 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13791 static struct hda_verb alc662_sue_init_verbs[] = {
13792 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
13793 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
13797 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
13798 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13799 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13803 /* Set Unsolicited Event*/
13804 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
13805 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13806 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13811 * generic initialization of ADC, input mixers and output mixers
13813 static struct hda_verb alc662_auto_init_verbs[] = {
13815 * Unmute ADC and set the default input to mic-in
13817 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13818 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13820 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
13822 * Note: PASD motherboards uses the Line In 2 as the input for front
13823 * panel mic (mic 2)
13825 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13826 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13827 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13828 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13829 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13830 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13833 * Set up output mixers (0x0c - 0x0f)
13835 /* set vol=0 to output mixers */
13836 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13837 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13838 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13840 /* set up input amps for analog loopback */
13841 /* Amp Indices: DAC = 0, mixer = 1 */
13842 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13843 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13844 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13845 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13846 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13847 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13850 /* FIXME: use matrix-type input source selection */
13851 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
13853 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13854 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13858 static struct hda_verb alc663_m51va_init_verbs[] = {
13859 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13860 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13861 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
13863 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
13865 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13866 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13870 static struct hda_verb alc663_g71v_init_verbs[] = {
13871 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13872 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
13873 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
13875 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13876 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13877 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
13879 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
13880 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
13881 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
13885 static struct hda_verb alc663_g50v_init_verbs[] = {
13886 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13887 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13888 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
13890 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13891 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13895 /* capture mixer elements */
13896 static struct snd_kcontrol_new alc662_capture_mixer[] = {
13897 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13898 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13900 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13901 /* The multiple "Capture Source" controls confuse alsamixer
13902 * So call somewhat different..
13904 /* .name = "Capture Source", */
13905 .name = "Input Source",
13907 .info = alc662_mux_enum_info,
13908 .get = alc662_mux_enum_get,
13909 .put = alc662_mux_enum_put,
13914 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
13916 unsigned int present;
13917 unsigned char bits;
13919 present = snd_hda_codec_read(codec, 0x14, 0,
13920 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13921 bits = present ? HDA_AMP_MUTE : 0;
13922 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13923 HDA_AMP_MUTE, bits);
13926 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
13928 unsigned int present;
13929 unsigned char bits;
13931 present = snd_hda_codec_read(codec, 0x1b, 0,
13932 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13933 bits = present ? HDA_AMP_MUTE : 0;
13934 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13935 HDA_AMP_MUTE, bits);
13936 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13937 HDA_AMP_MUTE, bits);
13940 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
13943 if ((res >> 26) == ALC880_HP_EVENT)
13944 alc662_lenovo_101e_all_automute(codec);
13945 if ((res >> 26) == ALC880_FRONT_EVENT)
13946 alc662_lenovo_101e_ispeaker_automute(codec);
13949 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
13951 unsigned int present;
13953 present = snd_hda_codec_read(codec, 0x18, 0,
13954 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13955 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13956 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
13957 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13958 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
13959 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13960 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
13961 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13962 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
13965 /* unsolicited event for HP jack sensing */
13966 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
13969 if ((res >> 26) == ALC880_HP_EVENT)
13970 alc262_hippo1_automute( codec );
13972 if ((res >> 26) == ALC880_MIC_EVENT)
13973 alc662_eeepc_mic_automute(codec);
13976 static void alc662_eeepc_inithook(struct hda_codec *codec)
13978 alc262_hippo1_automute( codec );
13979 alc662_eeepc_mic_automute(codec);
13982 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
13985 unsigned int present;
13987 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
13988 present = snd_hda_codec_read(codec, 0x14, 0,
13989 AC_VERB_GET_PIN_SENSE, 0);
13990 present = (present & 0x80000000) != 0;
13992 /* mute internal speaker */
13993 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
13994 HDA_AMP_MUTE, HDA_AMP_MUTE);
13996 /* unmute internal speaker if necessary */
13997 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13998 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
13999 HDA_AMP_MUTE, mute);
14003 /* unsolicited event for HP jack sensing */
14004 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
14007 if ((res >> 26) == ALC880_HP_EVENT)
14008 alc662_eeepc_ep20_automute(codec);
14011 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
14013 alc662_eeepc_ep20_automute(codec);
14016 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
14018 unsigned int present;
14019 unsigned char bits;
14021 present = snd_hda_codec_read(codec, 0x21, 0,
14022 AC_VERB_GET_PIN_SENSE, 0)
14023 & AC_PINSENSE_PRESENCE;
14024 bits = present ? HDA_AMP_MUTE : 0;
14025 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14026 HDA_AMP_MUTE, bits);
14029 static void alc663_m51va_mic_automute(struct hda_codec *codec)
14031 unsigned int present;
14033 present = snd_hda_codec_read(codec, 0x18, 0,
14034 AC_VERB_GET_PIN_SENSE, 0)
14035 & AC_PINSENSE_PRESENCE;
14036 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14037 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14038 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14039 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14040 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14041 0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
14042 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14043 0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
14046 static void alc663_m51va_unsol_event(struct hda_codec *codec,
14049 switch (res >> 26) {
14050 case ALC880_HP_EVENT:
14051 alc663_m51va_speaker_automute(codec);
14053 case ALC880_MIC_EVENT:
14054 alc663_m51va_mic_automute(codec);
14059 static void alc663_m51va_inithook(struct hda_codec *codec)
14061 alc663_m51va_speaker_automute(codec);
14062 alc663_m51va_mic_automute(codec);
14065 static void alc663_g71v_hp_automute(struct hda_codec *codec)
14067 unsigned int present;
14068 unsigned char bits;
14070 present = snd_hda_codec_read(codec, 0x21, 0,
14071 AC_VERB_GET_PIN_SENSE, 0)
14072 & AC_PINSENSE_PRESENCE;
14073 bits = present ? HDA_AMP_MUTE : 0;
14074 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
14075 HDA_AMP_MUTE, bits);
14076 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14077 HDA_AMP_MUTE, bits);
14080 static void alc663_g71v_front_automute(struct hda_codec *codec)
14082 unsigned int present;
14083 unsigned char bits;
14085 present = snd_hda_codec_read(codec, 0x15, 0,
14086 AC_VERB_GET_PIN_SENSE, 0)
14087 & AC_PINSENSE_PRESENCE;
14088 bits = present ? HDA_AMP_MUTE : 0;
14089 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14090 HDA_AMP_MUTE, bits);
14093 static void alc663_g71v_unsol_event(struct hda_codec *codec,
14096 switch (res >> 26) {
14097 case ALC880_HP_EVENT:
14098 alc663_g71v_hp_automute(codec);
14100 case ALC880_FRONT_EVENT:
14101 alc663_g71v_front_automute(codec);
14103 case ALC880_MIC_EVENT:
14104 alc662_eeepc_mic_automute(codec);
14109 static void alc663_g71v_inithook(struct hda_codec *codec)
14111 alc663_g71v_front_automute(codec);
14112 alc663_g71v_hp_automute(codec);
14113 alc662_eeepc_mic_automute(codec);
14116 static void alc663_g50v_unsol_event(struct hda_codec *codec,
14119 switch (res >> 26) {
14120 case ALC880_HP_EVENT:
14121 alc663_m51va_speaker_automute(codec);
14123 case ALC880_MIC_EVENT:
14124 alc662_eeepc_mic_automute(codec);
14129 static void alc663_g50v_inithook(struct hda_codec *codec)
14131 alc663_m51va_speaker_automute(codec);
14132 alc662_eeepc_mic_automute(codec);
14135 #ifdef CONFIG_SND_HDA_POWER_SAVE
14136 #define alc662_loopbacks alc880_loopbacks
14140 /* pcm configuration: identiacal with ALC880 */
14141 #define alc662_pcm_analog_playback alc880_pcm_analog_playback
14142 #define alc662_pcm_analog_capture alc880_pcm_analog_capture
14143 #define alc662_pcm_digital_playback alc880_pcm_digital_playback
14144 #define alc662_pcm_digital_capture alc880_pcm_digital_capture
14147 * configuration and preset
14149 static const char *alc662_models[ALC662_MODEL_LAST] = {
14150 [ALC662_3ST_2ch_DIG] = "3stack-dig",
14151 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig",
14152 [ALC662_3ST_6ch] = "3stack-6ch",
14153 [ALC662_5ST_DIG] = "6stack-dig",
14154 [ALC662_LENOVO_101E] = "lenovo-101e",
14155 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
14156 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
14157 [ALC663_ASUS_M51VA] = "m51va",
14158 [ALC663_ASUS_G71V] = "g71v",
14159 [ALC663_ASUS_H13] = "h13",
14160 [ALC663_ASUS_G50V] = "g50v",
14161 [ALC662_AUTO] = "auto",
14164 static struct snd_pci_quirk alc662_cfg_tbl[] = {
14165 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS G71V", ALC663_ASUS_G71V),
14166 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
14167 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS M51VA", ALC663_ASUS_G50V),
14168 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
14169 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
14170 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
14171 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
14172 SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
14173 SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
14174 SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
14178 static struct alc_config_preset alc662_presets[] = {
14179 [ALC662_3ST_2ch_DIG] = {
14180 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
14181 .init_verbs = { alc662_init_verbs },
14182 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14183 .dac_nids = alc662_dac_nids,
14184 .dig_out_nid = ALC662_DIGOUT_NID,
14185 .dig_in_nid = ALC662_DIGIN_NID,
14186 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14187 .channel_mode = alc662_3ST_2ch_modes,
14188 .input_mux = &alc662_capture_source,
14190 [ALC662_3ST_6ch_DIG] = {
14191 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
14192 alc662_capture_mixer },
14193 .init_verbs = { alc662_init_verbs },
14194 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14195 .dac_nids = alc662_dac_nids,
14196 .dig_out_nid = ALC662_DIGOUT_NID,
14197 .dig_in_nid = ALC662_DIGIN_NID,
14198 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14199 .channel_mode = alc662_3ST_6ch_modes,
14201 .input_mux = &alc662_capture_source,
14203 [ALC662_3ST_6ch] = {
14204 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
14205 alc662_capture_mixer },
14206 .init_verbs = { alc662_init_verbs },
14207 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14208 .dac_nids = alc662_dac_nids,
14209 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14210 .channel_mode = alc662_3ST_6ch_modes,
14212 .input_mux = &alc662_capture_source,
14214 [ALC662_5ST_DIG] = {
14215 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
14216 alc662_capture_mixer },
14217 .init_verbs = { alc662_init_verbs },
14218 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14219 .dac_nids = alc662_dac_nids,
14220 .dig_out_nid = ALC662_DIGOUT_NID,
14221 .dig_in_nid = ALC662_DIGIN_NID,
14222 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
14223 .channel_mode = alc662_5stack_modes,
14224 .input_mux = &alc662_capture_source,
14226 [ALC662_LENOVO_101E] = {
14227 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
14228 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
14229 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14230 .dac_nids = alc662_dac_nids,
14231 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14232 .channel_mode = alc662_3ST_2ch_modes,
14233 .input_mux = &alc662_lenovo_101e_capture_source,
14234 .unsol_event = alc662_lenovo_101e_unsol_event,
14235 .init_hook = alc662_lenovo_101e_all_automute,
14237 [ALC662_ASUS_EEEPC_P701] = {
14238 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
14239 .init_verbs = { alc662_init_verbs,
14240 alc662_eeepc_sue_init_verbs },
14241 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14242 .dac_nids = alc662_dac_nids,
14243 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14244 .channel_mode = alc662_3ST_2ch_modes,
14245 .input_mux = &alc662_eeepc_capture_source,
14246 .unsol_event = alc662_eeepc_unsol_event,
14247 .init_hook = alc662_eeepc_inithook,
14249 [ALC662_ASUS_EEEPC_EP20] = {
14250 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
14251 alc662_chmode_mixer },
14252 .init_verbs = { alc662_init_verbs,
14253 alc662_eeepc_ep20_sue_init_verbs },
14254 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14255 .dac_nids = alc662_dac_nids,
14256 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14257 .channel_mode = alc662_3ST_6ch_modes,
14258 .input_mux = &alc662_lenovo_101e_capture_source,
14259 .unsol_event = alc662_eeepc_ep20_unsol_event,
14260 .init_hook = alc662_eeepc_ep20_inithook,
14262 [ALC663_ASUS_M51VA] = {
14263 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
14264 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
14265 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14266 .dac_nids = alc662_dac_nids,
14267 .dig_out_nid = ALC662_DIGOUT_NID,
14268 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14269 .channel_mode = alc662_3ST_2ch_modes,
14270 .input_mux = &alc663_m51va_capture_source,
14271 .unsol_event = alc663_m51va_unsol_event,
14272 .init_hook = alc663_m51va_inithook,
14274 [ALC663_ASUS_G71V] = {
14275 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
14276 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
14277 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14278 .dac_nids = alc662_dac_nids,
14279 .dig_out_nid = ALC662_DIGOUT_NID,
14280 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14281 .channel_mode = alc662_3ST_2ch_modes,
14282 .input_mux = &alc662_eeepc_capture_source,
14283 .unsol_event = alc663_g71v_unsol_event,
14284 .init_hook = alc663_g71v_inithook,
14286 [ALC663_ASUS_H13] = {
14287 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
14288 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
14289 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14290 .dac_nids = alc662_dac_nids,
14291 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14292 .channel_mode = alc662_3ST_2ch_modes,
14293 .input_mux = &alc663_m51va_capture_source,
14294 .unsol_event = alc663_m51va_unsol_event,
14295 .init_hook = alc663_m51va_inithook,
14297 [ALC663_ASUS_G50V] = {
14298 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
14299 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
14300 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14301 .dac_nids = alc662_dac_nids,
14302 .dig_out_nid = ALC662_DIGOUT_NID,
14303 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14304 .channel_mode = alc662_3ST_6ch_modes,
14305 .input_mux = &alc663_capture_source,
14306 .unsol_event = alc663_g50v_unsol_event,
14307 .init_hook = alc663_g50v_inithook,
14313 * BIOS auto configuration
14316 /* add playback controls from the parsed DAC table */
14317 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
14318 const struct auto_pin_cfg *cfg)
14321 static const char *chname[4] = {
14322 "Front", "Surround", NULL /*CLFE*/, "Side"
14327 for (i = 0; i < cfg->line_outs; i++) {
14328 if (!spec->multiout.dac_nids[i])
14330 nid = alc880_idx_to_dac(i);
14333 err = add_control(spec, ALC_CTL_WIDGET_VOL,
14334 "Center Playback Volume",
14335 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
14339 err = add_control(spec, ALC_CTL_WIDGET_VOL,
14340 "LFE Playback Volume",
14341 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
14345 err = add_control(spec, ALC_CTL_BIND_MUTE,
14346 "Center Playback Switch",
14347 HDA_COMPOSE_AMP_VAL(nid, 1, 2,
14351 err = add_control(spec, ALC_CTL_BIND_MUTE,
14352 "LFE Playback Switch",
14353 HDA_COMPOSE_AMP_VAL(nid, 2, 2,
14358 sprintf(name, "%s Playback Volume", chname[i]);
14359 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14360 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
14364 sprintf(name, "%s Playback Switch", chname[i]);
14365 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14366 HDA_COMPOSE_AMP_VAL(nid, 3, 2,
14375 /* add playback controls for speaker and HP outputs */
14376 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
14386 if (alc880_is_fixed_pin(pin)) {
14387 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14388 /* printk("DAC nid=%x\n",nid); */
14389 /* specify the DAC as the extra output */
14390 if (!spec->multiout.hp_nid)
14391 spec->multiout.hp_nid = nid;
14393 spec->multiout.extra_out_nid[0] = nid;
14394 /* control HP volume/switch on the output mixer amp */
14395 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14396 sprintf(name, "%s Playback Volume", pfx);
14397 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14398 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
14401 sprintf(name, "%s Playback Switch", pfx);
14402 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14403 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
14406 } else if (alc880_is_multi_pin(pin)) {
14407 /* set manual connection */
14408 /* we have only a switch on HP-out PIN */
14409 sprintf(name, "%s Playback Switch", pfx);
14410 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14411 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14418 /* create playback/capture controls for input pins */
14419 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
14420 const struct auto_pin_cfg *cfg)
14422 struct hda_input_mux *imux = &spec->private_imux;
14425 for (i = 0; i < AUTO_PIN_LAST; i++) {
14426 if (alc880_is_input_pin(cfg->input_pins[i])) {
14427 idx = alc880_input_pin_idx(cfg->input_pins[i]);
14428 err = new_analog_input(spec, cfg->input_pins[i],
14429 auto_pin_cfg_labels[i],
14433 imux->items[imux->num_items].label =
14434 auto_pin_cfg_labels[i];
14435 imux->items[imux->num_items].index =
14436 alc880_input_pin_idx(cfg->input_pins[i]);
14443 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
14444 hda_nid_t nid, int pin_type,
14447 alc_set_pin_output(codec, nid, pin_type);
14448 /* need the manual connection? */
14449 if (alc880_is_multi_pin(nid)) {
14450 struct alc_spec *spec = codec->spec;
14451 int idx = alc880_multi_pin_idx(nid);
14452 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
14453 AC_VERB_SET_CONNECT_SEL,
14454 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
14458 static void alc662_auto_init_multi_out(struct hda_codec *codec)
14460 struct alc_spec *spec = codec->spec;
14463 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14464 for (i = 0; i <= HDA_SIDE; i++) {
14465 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14466 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14468 alc662_auto_set_output_and_unmute(codec, nid, pin_type,
14473 static void alc662_auto_init_hp_out(struct hda_codec *codec)
14475 struct alc_spec *spec = codec->spec;
14478 pin = spec->autocfg.hp_pins[0];
14479 if (pin) /* connect to front */
14481 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14482 pin = spec->autocfg.speaker_pins[0];
14484 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14487 #define alc662_is_input_pin(nid) alc880_is_input_pin(nid)
14488 #define ALC662_PIN_CD_NID ALC880_PIN_CD_NID
14490 static void alc662_auto_init_analog_input(struct hda_codec *codec)
14492 struct alc_spec *spec = codec->spec;
14495 for (i = 0; i < AUTO_PIN_LAST; i++) {
14496 hda_nid_t nid = spec->autocfg.input_pins[i];
14497 if (alc662_is_input_pin(nid)) {
14498 snd_hda_codec_write(codec, nid, 0,
14499 AC_VERB_SET_PIN_WIDGET_CONTROL,
14500 (i <= AUTO_PIN_FRONT_MIC ?
14501 PIN_VREF80 : PIN_IN));
14502 if (nid != ALC662_PIN_CD_NID)
14503 snd_hda_codec_write(codec, nid, 0,
14504 AC_VERB_SET_AMP_GAIN_MUTE,
14510 static int alc662_parse_auto_config(struct hda_codec *codec)
14512 struct alc_spec *spec = codec->spec;
14514 static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
14516 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14520 if (!spec->autocfg.line_outs)
14521 return 0; /* can't find valid BIOS pin config */
14523 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14526 err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
14529 err = alc662_auto_create_extra_out(spec,
14530 spec->autocfg.speaker_pins[0],
14534 err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
14538 err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
14542 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14544 if (spec->autocfg.dig_out_pin)
14545 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
14547 if (spec->kctl_alloc)
14548 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14550 spec->num_mux_defs = 1;
14551 spec->input_mux = &spec->private_imux;
14553 spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
14554 spec->mixers[spec->num_mixers] = alc662_capture_mixer;
14555 spec->num_mixers++;
14559 /* additional initialization for auto-configuration model */
14560 static void alc662_auto_init(struct hda_codec *codec)
14562 struct alc_spec *spec = codec->spec;
14563 alc662_auto_init_multi_out(codec);
14564 alc662_auto_init_hp_out(codec);
14565 alc662_auto_init_analog_input(codec);
14566 if (spec->unsol_event)
14567 alc_sku_automute(codec);
14570 static int patch_alc662(struct hda_codec *codec)
14572 struct alc_spec *spec;
14573 int err, board_config;
14575 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14579 codec->spec = spec;
14581 alc_fix_pll_init(codec, 0x20, 0x04, 15);
14583 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
14586 if (board_config < 0) {
14587 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
14588 "trying auto-probe from BIOS...\n");
14589 board_config = ALC662_AUTO;
14592 if (board_config == ALC662_AUTO) {
14593 /* automatic parse from the BIOS config */
14594 err = alc662_parse_auto_config(codec);
14600 "hda_codec: Cannot set up configuration "
14601 "from BIOS. Using base mode...\n");
14602 board_config = ALC662_3ST_2ch_DIG;
14606 if (board_config != ALC662_AUTO)
14607 setup_preset(spec, &alc662_presets[board_config]);
14609 if (codec->vendor_id == 0x10ec0663) {
14610 spec->stream_name_analog = "ALC663 Analog";
14611 spec->stream_name_digital = "ALC663 Digital";
14613 spec->stream_name_analog = "ALC662 Analog";
14614 spec->stream_name_digital = "ALC662 Digital";
14617 spec->stream_analog_playback = &alc662_pcm_analog_playback;
14618 spec->stream_analog_capture = &alc662_pcm_analog_capture;
14620 spec->stream_digital_playback = &alc662_pcm_digital_playback;
14621 spec->stream_digital_capture = &alc662_pcm_digital_capture;
14623 spec->adc_nids = alc662_adc_nids;
14624 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
14625 spec->capsrc_nids = alc662_capsrc_nids;
14627 spec->vmaster_nid = 0x02;
14629 codec->patch_ops = alc_patch_ops;
14630 if (board_config == ALC662_AUTO)
14631 spec->init_hook = alc662_auto_init;
14632 #ifdef CONFIG_SND_HDA_POWER_SAVE
14633 if (!spec->loopback.amplist)
14634 spec->loopback.amplist = alc662_loopbacks;
14643 struct hda_codec_preset snd_hda_preset_realtek[] = {
14644 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
14645 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
14646 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
14647 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
14648 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
14649 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
14650 .patch = patch_alc861 },
14651 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
14652 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
14653 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
14654 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
14655 .patch = patch_alc883 },
14656 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
14657 .patch = patch_alc662 },
14658 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
14659 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
14660 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
14661 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
14662 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
14663 .patch = patch_alc882 }, /* should be patch_alc883() in future */
14664 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
14665 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
14666 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
14667 {} /* terminator */