sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   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>
  10  *
  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.
  15  *
  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.
  20  *
  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
  24  */
  25
  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 <sound/jack.h>
  32 #include "hda_codec.h"
  33 #include "hda_local.h"
  34 #include "hda_beep.h"
  35
  36 #define ALC880_FRONT_EVENT              0x01
  37 #define ALC880_DCVOL_EVENT              0x02
  38 #define ALC880_HP_EVENT                 0x04
  39 #define ALC880_MIC_EVENT                0x08
  40
  41 /* ALC880 board config type */
  42 enum {
  43         ALC880_3ST,
  44         ALC880_3ST_DIG,
  45         ALC880_5ST,
  46         ALC880_5ST_DIG,
  47         ALC880_W810,
  48         ALC880_Z71V,
  49         ALC880_6ST,
  50         ALC880_6ST_DIG,
  51         ALC880_F1734,
  52         ALC880_ASUS,
  53         ALC880_ASUS_DIG,
  54         ALC880_ASUS_W1V,
  55         ALC880_ASUS_DIG2,
  56         ALC880_FUJITSU,
  57         ALC880_UNIWILL_DIG,
  58         ALC880_UNIWILL,
  59         ALC880_UNIWILL_P53,
  60         ALC880_CLEVO,
  61         ALC880_TCL_S700,
  62         ALC880_LG,
  63         ALC880_LG_LW,
  64         ALC880_MEDION_RIM,
  65 #ifdef CONFIG_SND_DEBUG
  66         ALC880_TEST,
  67 #endif
  68         ALC880_AUTO,
  69         ALC880_MODEL_LAST /* last tag */
  70 };
  71
  72 /* ALC260 models */
  73 enum {
  74         ALC260_BASIC,
  75         ALC260_HP,
  76         ALC260_HP_DC7600,
  77         ALC260_HP_3013,
  78         ALC260_FUJITSU_S702X,
  79         ALC260_ACER,
  80         ALC260_WILL,
  81         ALC260_REPLACER_672V,
  82         ALC260_FAVORIT100,
  83 #ifdef CONFIG_SND_DEBUG
  84         ALC260_TEST,
  85 #endif
  86         ALC260_AUTO,
  87         ALC260_MODEL_LAST /* last tag */
  88 };
  89
  90 /* ALC262 models */
  91 enum {
  92         ALC262_BASIC,
  93         ALC262_HIPPO,
  94         ALC262_HIPPO_1,
  95         ALC262_FUJITSU,
  96         ALC262_HP_BPC,
  97         ALC262_HP_BPC_D7000_WL,
  98         ALC262_HP_BPC_D7000_WF,
  99         ALC262_HP_TC_T5735,
 100         ALC262_HP_RP5700,
 101         ALC262_BENQ_ED8,
 102         ALC262_SONY_ASSAMD,
 103         ALC262_BENQ_T31,
 104         ALC262_ULTRA,
 105         ALC262_LENOVO_3000,
 106         ALC262_NEC,
 107         ALC262_TOSHIBA_S06,
 108         ALC262_TOSHIBA_RX1,
 109         ALC262_TYAN,
 110         ALC262_AUTO,
 111         ALC262_MODEL_LAST /* last tag */
 112 };
 113
 114 /* ALC268 models */
 115 enum {
 116         ALC267_QUANTA_IL1,
 117         ALC268_3ST,
 118         ALC268_TOSHIBA,
 119         ALC268_ACER,
 120         ALC268_ACER_DMIC,
 121         ALC268_ACER_ASPIRE_ONE,
 122         ALC268_DELL,
 123         ALC268_ZEPTO,
 124 #ifdef CONFIG_SND_DEBUG
 125         ALC268_TEST,
 126 #endif
 127         ALC268_AUTO,
 128         ALC268_MODEL_LAST /* last tag */
 129 };
 130
 131 /* ALC269 models */
 132 enum {
 133         ALC269_BASIC,
 134         ALC269_QUANTA_FL1,
 135         ALC269_AMIC,
 136         ALC269_DMIC,
 137         ALC269VB_AMIC,
 138         ALC269VB_DMIC,
 139         ALC269_FUJITSU,
 140         ALC269_LIFEBOOK,
 141         ALC271_ACER,
 142         ALC269_AUTO,
 143         ALC269_MODEL_LAST /* last tag */
 144 };
 145
 146 /* ALC861 models */
 147 enum {
 148         ALC861_3ST,
 149         ALC660_3ST,
 150         ALC861_3ST_DIG,
 151         ALC861_6ST_DIG,
 152         ALC861_UNIWILL_M31,
 153         ALC861_TOSHIBA,
 154         ALC861_ASUS,
 155         ALC861_ASUS_LAPTOP,
 156         ALC861_AUTO,
 157         ALC861_MODEL_LAST,
 158 };
 159
 160 /* ALC861-VD models */
 161 enum {
 162         ALC660VD_3ST,
 163         ALC660VD_3ST_DIG,
 164         ALC660VD_ASUS_V1S,
 165         ALC861VD_3ST,
 166         ALC861VD_3ST_DIG,
 167         ALC861VD_6ST_DIG,
 168         ALC861VD_LENOVO,
 169         ALC861VD_DALLAS,
 170         ALC861VD_HP,
 171         ALC861VD_AUTO,
 172         ALC861VD_MODEL_LAST,
 173 };
 174
 175 /* ALC662 models */
 176 enum {
 177         ALC662_3ST_2ch_DIG,
 178         ALC662_3ST_6ch_DIG,
 179         ALC662_3ST_6ch,
 180         ALC662_5ST_DIG,
 181         ALC662_LENOVO_101E,
 182         ALC662_ASUS_EEEPC_P701,
 183         ALC662_ASUS_EEEPC_EP20,
 184         ALC663_ASUS_M51VA,
 185         ALC663_ASUS_G71V,
 186         ALC663_ASUS_H13,
 187         ALC663_ASUS_G50V,
 188         ALC662_ECS,
 189         ALC663_ASUS_MODE1,
 190         ALC662_ASUS_MODE2,
 191         ALC663_ASUS_MODE3,
 192         ALC663_ASUS_MODE4,
 193         ALC663_ASUS_MODE5,
 194         ALC663_ASUS_MODE6,
 195         ALC663_ASUS_MODE7,
 196         ALC663_ASUS_MODE8,
 197         ALC272_DELL,
 198         ALC272_DELL_ZM1,
 199         ALC272_SAMSUNG_NC10,
 200         ALC662_AUTO,
 201         ALC662_MODEL_LAST,
 202 };
 203
 204 /* ALC882 models */
 205 enum {
 206         ALC882_3ST_DIG,
 207         ALC882_6ST_DIG,
 208         ALC882_ARIMA,
 209         ALC882_W2JC,
 210         ALC882_TARGA,
 211         ALC882_ASUS_A7J,
 212         ALC882_ASUS_A7M,
 213         ALC885_MACPRO,
 214         ALC885_MBA21,
 215         ALC885_MBP3,
 216         ALC885_MB5,
 217         ALC885_MACMINI3,
 218         ALC885_IMAC24,
 219         ALC885_IMAC91,
 220         ALC883_3ST_2ch_DIG,
 221         ALC883_3ST_6ch_DIG,
 222         ALC883_3ST_6ch,
 223         ALC883_6ST_DIG,
 224         ALC883_TARGA_DIG,
 225         ALC883_TARGA_2ch_DIG,
 226         ALC883_TARGA_8ch_DIG,
 227         ALC883_ACER,
 228         ALC883_ACER_ASPIRE,
 229         ALC888_ACER_ASPIRE_4930G,
 230         ALC888_ACER_ASPIRE_6530G,
 231         ALC888_ACER_ASPIRE_8930G,
 232         ALC888_ACER_ASPIRE_7730G,
 233         ALC883_MEDION,
 234         ALC883_MEDION_WIM2160,
 235         ALC883_LAPTOP_EAPD,
 236         ALC883_LENOVO_101E_2ch,
 237         ALC883_LENOVO_NB0763,
 238         ALC888_LENOVO_MS7195_DIG,
 239         ALC888_LENOVO_SKY,
 240         ALC883_HAIER_W66,
 241         ALC888_3ST_HP,
 242         ALC888_6ST_DELL,
 243         ALC883_MITAC,
 244         ALC883_CLEVO_M540R,
 245         ALC883_CLEVO_M720,
 246         ALC883_FUJITSU_PI2515,
 247         ALC888_FUJITSU_XA3530,
 248         ALC883_3ST_6ch_INTEL,
 249         ALC889A_INTEL,
 250         ALC889_INTEL,
 251         ALC888_ASUS_M90V,
 252         ALC888_ASUS_EEE1601,
 253         ALC889A_MB31,
 254         ALC1200_ASUS_P5Q,
 255         ALC883_SONY_VAIO_TT,
 256         ALC882_AUTO,
 257         ALC882_MODEL_LAST,
 258 };
 259
 260 /* ALC680 models */
 261 enum {
 262         ALC680_BASE,
 263         ALC680_AUTO,
 264         ALC680_MODEL_LAST,
 265 };
 266
 267 /* for GPIO Poll */
 268 #define GPIO_MASK       0x03
 269
 270 /* extra amp-initialization sequence types */
 271 enum {
 272         ALC_INIT_NONE,
 273         ALC_INIT_DEFAULT,
 274         ALC_INIT_GPIO1,
 275         ALC_INIT_GPIO2,
 276         ALC_INIT_GPIO3,
 277 };
 278
 279 struct alc_mic_route {
 280         hda_nid_t pin;
 281         unsigned char mux_idx;
 282         unsigned char amix_idx;
 283 };
 284
 285 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 286
 287 struct alc_customize_define {
 288         unsigned int  sku_cfg;
 289         unsigned char port_connectivity;
 290         unsigned char check_sum;
 291         unsigned char customization;
 292         unsigned char external_amp;
 293         unsigned int  enable_pcbeep:1;
 294         unsigned int  platform_type:1;
 295         unsigned int  swap:1;
 296         unsigned int  override:1;
 297         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
 298 };
 299
 300 struct alc_fixup;
 301
 302 struct alc_multi_io {
 303         hda_nid_t pin;          /* multi-io widget pin NID */
 304         hda_nid_t dac;          /* DAC to be connected */
 305         unsigned int ctl_in;    /* cached input-pin control value */
 306 };
 307
 308 enum {
 309         ALC_AUTOMUTE_PIN,       /* change the pin control */
 310         ALC_AUTOMUTE_AMP,       /* mute/unmute the pin AMP */
 311         ALC_AUTOMUTE_MIXER,     /* mute/unmute mixer widget AMP */
 312 };
 313
 314 struct alc_spec {
 315         /* codec parameterization */
 316         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
 317         unsigned int num_mixers;
 318         const struct snd_kcontrol_new *cap_mixer;       /* capture mixer */
 319         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 320
 321         const struct hda_verb *init_verbs[10];  /* initialization verbs
 322                                                  * don't forget NULL
 323                                                  * termination!
 324                                                  */
 325         unsigned int num_init_verbs;
 326
 327         char stream_name_analog[32];    /* analog PCM stream */
 328         const struct hda_pcm_stream *stream_analog_playback;
 329         const struct hda_pcm_stream *stream_analog_capture;
 330         const struct hda_pcm_stream *stream_analog_alt_playback;
 331         const struct hda_pcm_stream *stream_analog_alt_capture;
 332
 333         char stream_name_digital[32];   /* digital PCM stream */
 334         const struct hda_pcm_stream *stream_digital_playback;
 335         const struct hda_pcm_stream *stream_digital_capture;
 336
 337         /* playback */
 338         struct hda_multi_out multiout;  /* playback set-up
 339                                          * max_channels, dacs must be set
 340                                          * dig_out_nid and hp_nid are optional
 341                                          */
 342         hda_nid_t alt_dac_nid;
 343         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 344         int dig_out_type;
 345
 346         /* capture */
 347         unsigned int num_adc_nids;
 348         const hda_nid_t *adc_nids;
 349         const hda_nid_t *capsrc_nids;
 350         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 351
 352         /* capture setup for dynamic dual-adc switch */
 353         unsigned int cur_adc_idx;
 354         hda_nid_t cur_adc;
 355         unsigned int cur_adc_stream_tag;
 356         unsigned int cur_adc_format;
 357
 358         /* capture source */
 359         unsigned int num_mux_defs;
 360         const struct hda_input_mux *input_mux;
 361         unsigned int cur_mux[3];
 362         struct alc_mic_route ext_mic;
 363         struct alc_mic_route dock_mic;
 364         struct alc_mic_route int_mic;
 365
 366         /* channel model */
 367         const struct hda_channel_mode *channel_mode;
 368         int num_channel_mode;
 369         int need_dac_fix;
 370         int const_channel_count;
 371         int ext_channel_count;
 372
 373         /* PCM information */
 374         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 375
 376         /* dynamic controls, init_verbs and input_mux */
 377         struct auto_pin_cfg autocfg;
 378         struct alc_customize_define cdefine;
 379         struct snd_array kctls;
 380         struct hda_input_mux private_imux[3];
 381         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 382         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 383         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 384
 385         /* hooks */
 386         void (*init_hook)(struct hda_codec *codec);
 387         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 388 #ifdef CONFIG_SND_HDA_POWER_SAVE
 389         void (*power_hook)(struct hda_codec *codec);
 390 #endif
 391         void (*shutup)(struct hda_codec *codec);
 392
 393         /* for pin sensing */
 394         unsigned int jack_present: 1;
 395         unsigned int line_jack_present:1;
 396         unsigned int master_mute:1;
 397         unsigned int auto_mic:1;
 398         unsigned int automute:1;        /* HP automute enabled */
 399         unsigned int detect_line:1;     /* Line-out detection enabled */
 400         unsigned int automute_lines:1;  /* automute line-out as well */
 401         unsigned int automute_hp_lo:1;  /* both HP and LO available */
 402
 403         /* other flags */
 404         unsigned int no_analog :1; /* digital I/O only */
 405         unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
 406         unsigned int single_input_src:1;
 407
 408         /* auto-mute control */
 409         int automute_mode;
 410         hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
 411
 412         int init_amp;
 413         int codec_variant;      /* flag for other variants */
 414
 415         /* for virtual master */
 416         hda_nid_t vmaster_nid;
 417 #ifdef CONFIG_SND_HDA_POWER_SAVE
 418         struct hda_loopback_check loopback;
 419 #endif
 420
 421         /* for PLL fix */
 422         hda_nid_t pll_nid;
 423         unsigned int pll_coef_idx, pll_coef_bit;
 424
 425         /* fix-up list */
 426         int fixup_id;
 427         const struct alc_fixup *fixup_list;
 428         const char *fixup_name;
 429
 430         /* multi-io */
 431         int multi_ios;
 432         struct alc_multi_io multi_io[4];
 433 };
 434
 435 /*
 436  * configuration template - to be copied to the spec instance
 437  */
 438 struct alc_config_preset {
 439         const struct snd_kcontrol_new *mixers[5]; /* should be identical size
 440                                              * with spec
 441                                              */
 442         const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 443         const struct hda_verb *init_verbs[5];
 444         unsigned int num_dacs;
 445         const hda_nid_t *dac_nids;
 446         hda_nid_t dig_out_nid;          /* optional */
 447         hda_nid_t hp_nid;               /* optional */
 448         const hda_nid_t *slave_dig_outs;
 449         unsigned int num_adc_nids;
 450         const hda_nid_t *adc_nids;
 451         const hda_nid_t *capsrc_nids;
 452         hda_nid_t dig_in_nid;
 453         unsigned int num_channel_mode;
 454         const struct hda_channel_mode *channel_mode;
 455         int need_dac_fix;
 456         int const_channel_count;
 457         unsigned int num_mux_defs;
 458         const struct hda_input_mux *input_mux;
 459         void (*unsol_event)(struct hda_codec *, unsigned int);
 460         void (*setup)(struct hda_codec *);
 461         void (*init_hook)(struct hda_codec *);
 462 #ifdef CONFIG_SND_HDA_POWER_SAVE
 463         const struct hda_amp_list *loopbacks;
 464         void (*power_hook)(struct hda_codec *codec);
 465 #endif
 466 };
 467
 468
 469 /*
 470  * input MUX handling
 471  */
 472 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 473                              struct snd_ctl_elem_info *uinfo)
 474 {
 475         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 476         struct alc_spec *spec = codec->spec;
 477         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 478         if (mux_idx >= spec->num_mux_defs)
 479                 mux_idx = 0;
 480         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 481                 mux_idx = 0;
 482         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 483 }
 484
 485 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 486                             struct snd_ctl_elem_value *ucontrol)
 487 {
 488         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 489         struct alc_spec *spec = codec->spec;
 490         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 491
 492         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 493         return 0;
 494 }
 495
 496 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 497                             struct snd_ctl_elem_value *ucontrol)
 498 {
 499         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 500         struct alc_spec *spec = codec->spec;
 501         const struct hda_input_mux *imux;
 502         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 503         unsigned int mux_idx;
 504         hda_nid_t nid = spec->capsrc_nids ?
 505                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 506         unsigned int type;
 507
 508         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 509         imux = &spec->input_mux[mux_idx];
 510         if (!imux->num_items && mux_idx > 0)
 511                 imux = &spec->input_mux[0];
 512
 513         type = get_wcaps_type(get_wcaps(codec, nid));
 514         if (type == AC_WID_AUD_MIX) {
 515                 /* Matrix-mixer style (e.g. ALC882) */
 516                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 517                 unsigned int i, idx;
 518
 519                 idx = ucontrol->value.enumerated.item[0];
 520                 if (idx >= imux->num_items)
 521                         idx = imux->num_items - 1;
 522                 if (*cur_val == idx)
 523                         return 0;
 524                 for (i = 0; i < imux->num_items; i++) {
 525                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 526                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 527                                                  imux->items[i].index,
 528                                                  HDA_AMP_MUTE, v);
 529                 }
 530                 *cur_val = idx;
 531                 return 1;
 532         } else {
 533                 /* MUX style (e.g. ALC880) */
 534                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 535                                              &spec->cur_mux[adc_idx]);
 536         }
 537 }
 538
 539 /*
 540  * channel mode setting
 541  */
 542 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 543                             struct snd_ctl_elem_info *uinfo)
 544 {
 545         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 546         struct alc_spec *spec = codec->spec;
 547         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 548                                     spec->num_channel_mode);
 549 }
 550
 551 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 552                            struct snd_ctl_elem_value *ucontrol)
 553 {
 554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 555         struct alc_spec *spec = codec->spec;
 556         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 557                                    spec->num_channel_mode,
 558                                    spec->ext_channel_count);
 559 }
 560
 561 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 562                            struct snd_ctl_elem_value *ucontrol)
 563 {
 564         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 565         struct alc_spec *spec = codec->spec;
 566         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 567                                       spec->num_channel_mode,
 568                                       &spec->ext_channel_count);
 569         if (err >= 0 && !spec->const_channel_count) {
 570                 spec->multiout.max_channels = spec->ext_channel_count;
 571                 if (spec->need_dac_fix)
 572                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 573         }
 574         return err;
 575 }
 576
 577 /*
 578  * Control the mode of pin widget settings via the mixer.  "pc" is used
 579  * instead of "%" to avoid consequences of accidentally treating the % as
 580  * being part of a format specifier.  Maximum allowed length of a value is
 581  * 63 characters plus NULL terminator.
 582  *
 583  * Note: some retasking pin complexes seem to ignore requests for input
 584  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 585  * are requested.  Therefore order this list so that this behaviour will not
 586  * cause problems when mixer clients move through the enum sequentially.
 587  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 588  * March 2006.
 589  */
 590 static const char * const alc_pin_mode_names[] = {
 591         "Mic 50pc bias", "Mic 80pc bias",
 592         "Line in", "Line out", "Headphone out",
 593 };
 594 static const unsigned char alc_pin_mode_values[] = {
 595         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 596 };
 597 /* The control can present all 5 options, or it can limit the options based
 598  * in the pin being assumed to be exclusively an input or an output pin.  In
 599  * addition, "input" pins may or may not process the mic bias option
 600  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 601  * accept requests for bias as of chip versions up to March 2006) and/or
 602  * wiring in the computer.
 603  */
 604 #define ALC_PIN_DIR_IN              0x00
 605 #define ALC_PIN_DIR_OUT             0x01
 606 #define ALC_PIN_DIR_INOUT           0x02
 607 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 608 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 609
 610 /* Info about the pin modes supported by the different pin direction modes.
 611  * For each direction the minimum and maximum values are given.
 612  */
 613 static const signed char alc_pin_mode_dir_info[5][2] = {
 614         { 0, 2 },    /* ALC_PIN_DIR_IN */
 615         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 616         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 617         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 618         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 619 };
 620 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 621 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 622 #define alc_pin_mode_n_items(_dir) \
 623         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 624
 625 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 626                              struct snd_ctl_elem_info *uinfo)
 627 {
 628         unsigned int item_num = uinfo->value.enumerated.item;
 629         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 630
 631         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 632         uinfo->count = 1;
 633         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 634
 635         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 636                 item_num = alc_pin_mode_min(dir);
 637         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 638         return 0;
 639 }
 640
 641 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 642                             struct snd_ctl_elem_value *ucontrol)
 643 {
 644         unsigned int i;
 645         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 646         hda_nid_t nid = kcontrol->private_value & 0xffff;
 647         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 648         long *valp = ucontrol->value.integer.value;
 649         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 650                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 651                                                  0x00);
 652
 653         /* Find enumerated value for current pinctl setting */
 654         i = alc_pin_mode_min(dir);
 655         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 656                 i++;
 657         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 658         return 0;
 659 }
 660
 661 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 662                             struct snd_ctl_elem_value *ucontrol)
 663 {
 664         signed int change;
 665         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 666         hda_nid_t nid = kcontrol->private_value & 0xffff;
 667         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 668         long val = *ucontrol->value.integer.value;
 669         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 670                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 671                                                  0x00);
 672
 673         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 674                 val = alc_pin_mode_min(dir);
 675
 676         change = pinctl != alc_pin_mode_values[val];
 677         if (change) {
 678                 /* Set pin mode to that requested */
 679                 snd_hda_codec_write_cache(codec, nid, 0,
 680                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 681                                           alc_pin_mode_values[val]);
 682
 683                 /* Also enable the retasking pin's input/output as required
 684                  * for the requested pin mode.  Enum values of 2 or less are
 685                  * input modes.
 686                  *
 687                  * Dynamically switching the input/output buffers probably
 688                  * reduces noise slightly (particularly on input) so we'll
 689                  * do it.  However, having both input and output buffers
 690                  * enabled simultaneously doesn't seem to be problematic if
 691                  * this turns out to be necessary in the future.
 692                  */
 693                 if (val <= 2) {
 694                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 695                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 696                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 697                                                  HDA_AMP_MUTE, 0);
 698                 } else {
 699                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 700                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 701                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 702                                                  HDA_AMP_MUTE, 0);
 703                 }
 704         }
 705         return change;
 706 }
 707
 708 #define ALC_PIN_MODE(xname, nid, dir) \
 709         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 710           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 711           .info = alc_pin_mode_info, \
 712           .get = alc_pin_mode_get, \
 713           .put = alc_pin_mode_put, \
 714           .private_value = nid | (dir<<16) }
 715
 716 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 717  * together using a mask with more than one bit set.  This control is
 718  * currently used only by the ALC260 test model.  At this stage they are not
 719  * needed for any "production" models.
 720  */
 721 #ifdef CONFIG_SND_DEBUG
 722 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 723
 724 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 725                              struct snd_ctl_elem_value *ucontrol)
 726 {
 727         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 728         hda_nid_t nid = kcontrol->private_value & 0xffff;
 729         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 730         long *valp = ucontrol->value.integer.value;
 731         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 732                                               AC_VERB_GET_GPIO_DATA, 0x00);
 733
 734         *valp = (val & mask) != 0;
 735         return 0;
 736 }
 737 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 738                              struct snd_ctl_elem_value *ucontrol)
 739 {
 740         signed int change;
 741         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 742         hda_nid_t nid = kcontrol->private_value & 0xffff;
 743         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 744         long val = *ucontrol->value.integer.value;
 745         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 746                                                     AC_VERB_GET_GPIO_DATA,
 747                                                     0x00);
 748
 749         /* Set/unset the masked GPIO bit(s) as needed */
 750         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 751         if (val == 0)
 752                 gpio_data &= ~mask;
 753         else
 754                 gpio_data |= mask;
 755         snd_hda_codec_write_cache(codec, nid, 0,
 756                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 757
 758         return change;
 759 }
 760 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 761         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 762           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 763           .info = alc_gpio_data_info, \
 764           .get = alc_gpio_data_get, \
 765           .put = alc_gpio_data_put, \
 766           .private_value = nid | (mask<<16) }
 767 #endif   /* CONFIG_SND_DEBUG */
 768
 769 /* A switch control to allow the enabling of the digital IO pins on the
 770  * ALC260.  This is incredibly simplistic; the intention of this control is
 771  * to provide something in the test model allowing digital outputs to be
 772  * identified if present.  If models are found which can utilise these
 773  * outputs a more complete mixer control can be devised for those models if
 774  * necessary.
 775  */
 776 #ifdef CONFIG_SND_DEBUG
 777 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 778
 779 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 780                               struct snd_ctl_elem_value *ucontrol)
 781 {
 782         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 783         hda_nid_t nid = kcontrol->private_value & 0xffff;
 784         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 785         long *valp = ucontrol->value.integer.value;
 786         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 787                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 788
 789         *valp = (val & mask) != 0;
 790         return 0;
 791 }
 792 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 793                               struct snd_ctl_elem_value *ucontrol)
 794 {
 795         signed int change;
 796         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 797         hda_nid_t nid = kcontrol->private_value & 0xffff;
 798         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 799         long val = *ucontrol->value.integer.value;
 800         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 801                                                     AC_VERB_GET_DIGI_CONVERT_1,
 802                                                     0x00);
 803
 804         /* Set/unset the masked control bit(s) as needed */
 805         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 806         if (val==0)
 807                 ctrl_data &= ~mask;
 808         else
 809                 ctrl_data |= mask;
 810         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 811                                   ctrl_data);
 812
 813         return change;
 814 }
 815 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 816         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 817           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 818           .info = alc_spdif_ctrl_info, \
 819           .get = alc_spdif_ctrl_get, \
 820           .put = alc_spdif_ctrl_put, \
 821           .private_value = nid | (mask<<16) }
 822 #endif   /* CONFIG_SND_DEBUG */
 823
 824 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 825  * Again, this is only used in the ALC26x test models to help identify when
 826  * the EAPD line must be asserted for features to work.
 827  */
 828 #ifdef CONFIG_SND_DEBUG
 829 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 830
 831 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 832                               struct snd_ctl_elem_value *ucontrol)
 833 {
 834         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 835         hda_nid_t nid = kcontrol->private_value & 0xffff;
 836         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 837         long *valp = ucontrol->value.integer.value;
 838         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 839                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 840
 841         *valp = (val & mask) != 0;
 842         return 0;
 843 }
 844
 845 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 846                               struct snd_ctl_elem_value *ucontrol)
 847 {
 848         int change;
 849         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 850         hda_nid_t nid = kcontrol->private_value & 0xffff;
 851         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 852         long val = *ucontrol->value.integer.value;
 853         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 854                                                     AC_VERB_GET_EAPD_BTLENABLE,
 855                                                     0x00);
 856
 857         /* Set/unset the masked control bit(s) as needed */
 858         change = (!val ? 0 : mask) != (ctrl_data & mask);
 859         if (!val)
 860                 ctrl_data &= ~mask;
 861         else
 862                 ctrl_data |= mask;
 863         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 864                                   ctrl_data);
 865
 866         return change;
 867 }
 868
 869 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 870         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 871           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 872           .info = alc_eapd_ctrl_info, \
 873           .get = alc_eapd_ctrl_get, \
 874           .put = alc_eapd_ctrl_put, \
 875           .private_value = nid | (mask<<16) }
 876 #endif   /* CONFIG_SND_DEBUG */
 877
 878 /*
 879  * set up the input pin config (depending on the given auto-pin type)
 880  */
 881 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 882                               int auto_pin_type)
 883 {
 884         unsigned int val = PIN_IN;
 885
 886         if (auto_pin_type == AUTO_PIN_MIC) {
 887                 unsigned int pincap;
 888                 unsigned int oldval;
 889                 oldval = snd_hda_codec_read(codec, nid, 0,
 890                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 891                 pincap = snd_hda_query_pin_caps(codec, nid);
 892                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 893                 /* if the default pin setup is vref50, we give it priority */
 894                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 895                         val = PIN_VREF80;
 896                 else if (pincap & AC_PINCAP_VREF_50)
 897                         val = PIN_VREF50;
 898                 else if (pincap & AC_PINCAP_VREF_100)
 899                         val = PIN_VREF100;
 900                 else if (pincap & AC_PINCAP_VREF_GRD)
 901                         val = PIN_VREFGRD;
 902         }
 903         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 904 }
 905
 906 static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
 907 {
 908         struct alc_spec *spec = codec->spec;
 909         struct auto_pin_cfg *cfg = &spec->autocfg;
 910
 911         if (!cfg->line_outs) {
 912                 while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
 913                        cfg->line_out_pins[cfg->line_outs])
 914                         cfg->line_outs++;
 915         }
 916         if (!cfg->speaker_outs) {
 917                 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
 918                        cfg->speaker_pins[cfg->speaker_outs])
 919                         cfg->speaker_outs++;
 920         }
 921         if (!cfg->hp_outs) {
 922                 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
 923                        cfg->hp_pins[cfg->hp_outs])
 924                         cfg->hp_outs++;
 925         }
 926 }
 927
 928 /*
 929  */
 930 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
 931 {
 932         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 933                 return;
 934         spec->mixers[spec->num_mixers++] = mix;
 935 }
 936
 937 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 938 {
 939         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 940                 return;
 941         spec->init_verbs[spec->num_init_verbs++] = verb;
 942 }
 943
 944 /*
 945  * set up from the preset table
 946  */
 947 static void setup_preset(struct hda_codec *codec,
 948                          const struct alc_config_preset *preset)
 949 {
 950         struct alc_spec *spec = codec->spec;
 951         int i;
 952
 953         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 954                 add_mixer(spec, preset->mixers[i]);
 955         spec->cap_mixer = preset->cap_mixer;
 956         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 957              i++)
 958                 add_verb(spec, preset->init_verbs[i]);
 959
 960         spec->channel_mode = preset->channel_mode;
 961         spec->num_channel_mode = preset->num_channel_mode;
 962         spec->need_dac_fix = preset->need_dac_fix;
 963         spec->const_channel_count = preset->const_channel_count;
 964
 965         if (preset->const_channel_count)
 966                 spec->multiout.max_channels = preset->const_channel_count;
 967         else
 968                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 969         spec->ext_channel_count = spec->channel_mode[0].channels;
 970
 971         spec->multiout.num_dacs = preset->num_dacs;
 972         spec->multiout.dac_nids = preset->dac_nids;
 973         spec->multiout.dig_out_nid = preset->dig_out_nid;
 974         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 975         spec->multiout.hp_nid = preset->hp_nid;
 976
 977         spec->num_mux_defs = preset->num_mux_defs;
 978         if (!spec->num_mux_defs)
 979                 spec->num_mux_defs = 1;
 980         spec->input_mux = preset->input_mux;
 981
 982         spec->num_adc_nids = preset->num_adc_nids;
 983         spec->adc_nids = preset->adc_nids;
 984         spec->capsrc_nids = preset->capsrc_nids;
 985         spec->dig_in_nid = preset->dig_in_nid;
 986
 987         spec->unsol_event = preset->unsol_event;
 988         spec->init_hook = preset->init_hook;
 989 #ifdef CONFIG_SND_HDA_POWER_SAVE
 990         spec->power_hook = preset->power_hook;
 991         spec->loopback.amplist = preset->loopbacks;
 992 #endif
 993
 994         if (preset->setup)
 995                 preset->setup(codec);
 996
 997         alc_fixup_autocfg_pin_nums(codec);
 998 }
 999
1000 /* Enable GPIO mask and set output */
1001 static const struct hda_verb alc_gpio1_init_verbs[] = {
1002         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
1003         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
1004         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
1005         { }
1006 };
1007
1008 static const struct hda_verb alc_gpio2_init_verbs[] = {
1009         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
1010         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
1011         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
1012         { }
1013 };
1014
1015 static const struct hda_verb alc_gpio3_init_verbs[] = {
1016         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
1017         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
1018         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
1019         { }
1020 };
1021
1022 /*
1023  * Fix hardware PLL issue
1024  * On some codecs, the analog PLL gating control must be off while
1025  * the default value is 1.
1026  */
1027 static void alc_fix_pll(struct hda_codec *codec)
1028 {
1029         struct alc_spec *spec = codec->spec;
1030         unsigned int val;
1031
1032         if (!spec->pll_nid)
1033                 return;
1034         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1035                             spec->pll_coef_idx);
1036         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1037                                  AC_VERB_GET_PROC_COEF, 0);
1038         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1039                             spec->pll_coef_idx);
1040         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1041                             val & ~(1 << spec->pll_coef_bit));
1042 }
1043
1044 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1045                              unsigned int coef_idx, unsigned int coef_bit)
1046 {
1047         struct alc_spec *spec = codec->spec;
1048         spec->pll_nid = nid;
1049         spec->pll_coef_idx = coef_idx;
1050         spec->pll_coef_bit = coef_bit;
1051         alc_fix_pll(codec);
1052 }
1053
1054 static int alc_init_jacks(struct hda_codec *codec)
1055 {
1056 #ifdef CONFIG_SND_HDA_INPUT_JACK
1057         struct alc_spec *spec = codec->spec;
1058         int err;
1059         unsigned int hp_nid = spec->autocfg.hp_pins[0];
1060         unsigned int mic_nid = spec->ext_mic.pin;
1061         unsigned int dock_nid = spec->dock_mic.pin;
1062
1063         if (hp_nid) {
1064                 err = snd_hda_input_jack_add(codec, hp_nid,
1065                                              SND_JACK_HEADPHONE, NULL);
1066                 if (err < 0)
1067                         return err;
1068                 snd_hda_input_jack_report(codec, hp_nid);
1069         }
1070
1071         if (mic_nid) {
1072                 err = snd_hda_input_jack_add(codec, mic_nid,
1073                                              SND_JACK_MICROPHONE, NULL);
1074                 if (err < 0)
1075                         return err;
1076                 snd_hda_input_jack_report(codec, mic_nid);
1077         }
1078         if (dock_nid) {
1079                 err = snd_hda_input_jack_add(codec, dock_nid,
1080                                              SND_JACK_MICROPHONE, NULL);
1081                 if (err < 0)
1082                         return err;
1083                 snd_hda_input_jack_report(codec, dock_nid);
1084         }
1085 #endif /* CONFIG_SND_HDA_INPUT_JACK */
1086         return 0;
1087 }
1088
1089 static int detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
1090 {
1091         int i, present = 0;
1092
1093         for (i = 0; i < num_pins; i++) {
1094                 hda_nid_t nid = pins[i];
1095                 if (!nid)
1096                         break;
1097                 snd_hda_input_jack_report(codec, nid);
1098                 present |= snd_hda_jack_detect(codec, nid);
1099         }
1100         return present;
1101 }
1102
1103 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
1104                         bool mute, bool hp_out)
1105 {
1106         struct alc_spec *spec = codec->spec;
1107         unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
1108         unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
1109         int i;
1110
1111         for (i = 0; i < num_pins; i++) {
1112                 hda_nid_t nid = pins[i];
1113                 if (!nid)
1114                         break;
1115                 switch (spec->automute_mode) {
1116                 case ALC_AUTOMUTE_PIN:
1117                         snd_hda_codec_write(codec, nid, 0,
1118                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1119                                             pin_bits);
1120                         break;
1121                 case ALC_AUTOMUTE_AMP:
1122                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1123                                                  HDA_AMP_MUTE, mute_bits);
1124                         break;
1125                 case ALC_AUTOMUTE_MIXER:
1126                         nid = spec->automute_mixer_nid[i];
1127                         if (!nid)
1128                                 break;
1129                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
1130                                                  HDA_AMP_MUTE, mute_bits);
1131                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
1132                                                  HDA_AMP_MUTE, mute_bits);
1133                         break;
1134                 }
1135         }
1136 }
1137
1138 /* Toggle internal speakers muting */
1139 static void update_speakers(struct hda_codec *codec)
1140 {
1141         struct alc_spec *spec = codec->spec;
1142         int on;
1143
1144         /* Control HP pins/amps depending on master_mute state;
1145          * in general, HP pins/amps control should be enabled in all cases,
1146          * but currently set only for master_mute, just to be safe
1147          */
1148         do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
1149                     spec->autocfg.hp_pins, spec->master_mute, true);
1150
1151         if (!spec->automute)
1152                 on = 0;
1153         else
1154                 on = spec->jack_present | spec->line_jack_present;
1155         on |= spec->master_mute;
1156         do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
1157                     spec->autocfg.speaker_pins, on, false);
1158
1159         /* toggle line-out mutes if needed, too */
1160         /* if LO is a copy of either HP or Speaker, don't need to handle it */
1161         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
1162             spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
1163                 return;
1164         if (!spec->automute_lines || !spec->automute)
1165                 on = 0;
1166         else
1167                 on = spec->jack_present;
1168         on |= spec->master_mute;
1169         do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
1170                     spec->autocfg.line_out_pins, on, false);
1171 }
1172
1173 static void alc_hp_automute(struct hda_codec *codec)
1174 {
1175         struct alc_spec *spec = codec->spec;
1176
1177         if (!spec->automute)
1178                 return;
1179         spec->jack_present =
1180                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
1181                              spec->autocfg.hp_pins);
1182         update_speakers(codec);
1183 }
1184
1185 static void alc_line_automute(struct hda_codec *codec)
1186 {
1187         struct alc_spec *spec = codec->spec;
1188
1189         if (!spec->automute || !spec->detect_line)
1190                 return;
1191         spec->line_jack_present =
1192                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
1193                              spec->autocfg.line_out_pins);
1194         update_speakers(codec);
1195 }
1196
1197 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1198                                 hda_nid_t nid)
1199 {
1200         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1201         int i, nums;
1202
1203         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1204         for (i = 0; i < nums; i++)
1205                 if (conn[i] == nid)
1206                         return i;
1207         return -1;
1208 }
1209
1210 /* switch the current ADC according to the jack state */
1211 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1212 {
1213         struct alc_spec *spec = codec->spec;
1214         unsigned int present;
1215         hda_nid_t new_adc;
1216
1217         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1218         if (present)
1219                 spec->cur_adc_idx = 1;
1220         else
1221                 spec->cur_adc_idx = 0;
1222         new_adc = spec->adc_nids[spec->cur_adc_idx];
1223         if (spec->cur_adc && spec->cur_adc != new_adc) {
1224                 /* stream is running, let's swap the current ADC */
1225                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1226                 spec->cur_adc = new_adc;
1227                 snd_hda_codec_setup_stream(codec, new_adc,
1228                                            spec->cur_adc_stream_tag, 0,
1229                                            spec->cur_adc_format);
1230         }
1231 }
1232
1233 static void alc_mic_automute(struct hda_codec *codec)
1234 {
1235         struct alc_spec *spec = codec->spec;
1236         struct alc_mic_route *dead1, *dead2, *alive;
1237         unsigned int present, type;
1238         hda_nid_t cap_nid;
1239
1240         if (!spec->auto_mic)
1241                 return;
1242         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1243                 return;
1244         if (snd_BUG_ON(!spec->adc_nids))
1245                 return;
1246
1247         if (spec->dual_adc_switch) {
1248                 alc_dual_mic_adc_auto_switch(codec);
1249                 return;
1250         }
1251
1252         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1253
1254         alive = &spec->int_mic;
1255         dead1 = &spec->ext_mic;
1256         dead2 = &spec->dock_mic;
1257
1258         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1259         if (present) {
1260                 alive = &spec->ext_mic;
1261                 dead1 = &spec->int_mic;
1262                 dead2 = &spec->dock_mic;
1263         }
1264         if (!present && spec->dock_mic.pin > 0) {
1265                 present = snd_hda_jack_detect(codec, spec->dock_mic.pin);
1266                 if (present) {
1267                         alive = &spec->dock_mic;
1268                         dead1 = &spec->int_mic;
1269                         dead2 = &spec->ext_mic;
1270                 }
1271                 snd_hda_input_jack_report(codec, spec->dock_mic.pin);
1272         }
1273
1274         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1275         if (type == AC_WID_AUD_MIX) {
1276                 /* Matrix-mixer style (e.g. ALC882) */
1277                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1278                                          alive->mux_idx,
1279                                          HDA_AMP_MUTE, 0);
1280                 if (dead1->pin > 0)
1281                         snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1282                                                  dead1->mux_idx,
1283                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
1284                 if (dead2->pin > 0)
1285                         snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1286                                                  dead2->mux_idx,
1287                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
1288         } else {
1289                 /* MUX style (e.g. ALC880) */
1290                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1291                                           AC_VERB_SET_CONNECT_SEL,
1292                                           alive->mux_idx);
1293         }
1294         snd_hda_input_jack_report(codec, spec->ext_mic.pin);
1295
1296         /* FIXME: analog mixer */
1297 }
1298
1299 /* unsolicited event for HP jack sensing */
1300 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1301 {
1302         if (codec->vendor_id == 0x10ec0880)
1303                 res >>= 28;
1304         else
1305                 res >>= 26;
1306         switch (res) {
1307         case ALC880_HP_EVENT:
1308                 alc_hp_automute(codec);
1309                 break;
1310         case ALC880_FRONT_EVENT:
1311                 alc_line_automute(codec);
1312                 break;
1313         case ALC880_MIC_EVENT:
1314                 alc_mic_automute(codec);
1315                 break;
1316         }
1317 }
1318
1319 static void alc_inithook(struct hda_codec *codec)
1320 {
1321         alc_hp_automute(codec);
1322         alc_line_automute(codec);
1323         alc_mic_automute(codec);
1324 }
1325
1326 /* additional initialization for ALC888 variants */
1327 static void alc888_coef_init(struct hda_codec *codec)
1328 {
1329         unsigned int tmp;
1330
1331         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1332         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1333         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1334         if ((tmp & 0xf0) == 0x20)
1335                 /* alc888S-VC */
1336                 snd_hda_codec_read(codec, 0x20, 0,
1337                                    AC_VERB_SET_PROC_COEF, 0x830);
1338          else
1339                  /* alc888-VB */
1340                  snd_hda_codec_read(codec, 0x20, 0,
1341                                     AC_VERB_SET_PROC_COEF, 0x3030);
1342 }
1343
1344 static void alc889_coef_init(struct hda_codec *codec)
1345 {
1346         unsigned int tmp;
1347
1348         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1349         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1350         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1351         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1352 }
1353
1354 /* turn on/off EAPD control (only if available) */
1355 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1356 {
1357         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1358                 return;
1359         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1360                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1361                                     on ? 2 : 0);
1362 }
1363
1364 /* turn on/off EAPD controls of the codec */
1365 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
1366 {
1367         /* We currently only handle front, HP */
1368         switch (codec->vendor_id) {
1369         case 0x10ec0260:
1370                 set_eapd(codec, 0x0f, on);
1371                 set_eapd(codec, 0x10, on);
1372                 break;
1373         case 0x10ec0262:
1374         case 0x10ec0267:
1375         case 0x10ec0268:
1376         case 0x10ec0269:
1377         case 0x10ec0270:
1378         case 0x10ec0272:
1379         case 0x10ec0660:
1380         case 0x10ec0662:
1381         case 0x10ec0663:
1382         case 0x10ec0665:
1383         case 0x10ec0862:
1384         case 0x10ec0889:
1385         case 0x10ec0892:
1386                 set_eapd(codec, 0x14, on);
1387                 set_eapd(codec, 0x15, on);
1388                 break;
1389         }
1390 }
1391
1392 /* generic shutup callback;
1393  * just turning off EPAD and a little pause for avoiding pop-noise
1394  */
1395 static void alc_eapd_shutup(struct hda_codec *codec)
1396 {
1397         alc_auto_setup_eapd(codec, false);
1398         msleep(200);
1399 }
1400
1401 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1402 {
1403         unsigned int tmp;
1404
1405         switch (type) {
1406         case ALC_INIT_GPIO1:
1407                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1408                 break;
1409         case ALC_INIT_GPIO2:
1410                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1411                 break;
1412         case ALC_INIT_GPIO3:
1413                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1414                 break;
1415         case ALC_INIT_DEFAULT:
1416                 alc_auto_setup_eapd(codec, true);
1417                 switch (codec->vendor_id) {
1418                 case 0x10ec0260:
1419                         snd_hda_codec_write(codec, 0x1a, 0,
1420                                             AC_VERB_SET_COEF_INDEX, 7);
1421                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1422                                                  AC_VERB_GET_PROC_COEF, 0);
1423                         snd_hda_codec_write(codec, 0x1a, 0,
1424                                             AC_VERB_SET_COEF_INDEX, 7);
1425                         snd_hda_codec_write(codec, 0x1a, 0,
1426                                             AC_VERB_SET_PROC_COEF,
1427                                             tmp | 0x2010);
1428                         break;
1429                 case 0x10ec0262:
1430                 case 0x10ec0880:
1431                 case 0x10ec0882:
1432                 case 0x10ec0883:
1433                 case 0x10ec0885:
1434                 case 0x10ec0887:
1435                 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
1436                         alc889_coef_init(codec);
1437                         break;
1438                 case 0x10ec0888:
1439                         alc888_coef_init(codec);
1440                         break;
1441 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1442                 case 0x10ec0267:
1443                 case 0x10ec0268:
1444                         snd_hda_codec_write(codec, 0x20, 0,
1445                                             AC_VERB_SET_COEF_INDEX, 7);
1446                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1447                                                  AC_VERB_GET_PROC_COEF, 0);
1448                         snd_hda_codec_write(codec, 0x20, 0,
1449                                             AC_VERB_SET_COEF_INDEX, 7);
1450                         snd_hda_codec_write(codec, 0x20, 0,
1451                                             AC_VERB_SET_PROC_COEF,
1452                                             tmp | 0x3000);
1453                         break;
1454 #endif /* XXX */
1455                 }
1456                 break;
1457         }
1458 }
1459
1460 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
1461                                   struct snd_ctl_elem_info *uinfo)
1462 {
1463         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1464         struct alc_spec *spec = codec->spec;
1465         static const char * const texts2[] = {
1466                 "Disabled", "Enabled"
1467         };
1468         static const char * const texts3[] = {
1469                 "Disabled", "Speaker Only", "Line-Out+Speaker"
1470         };
1471         const char * const *texts;
1472
1473         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1474         uinfo->count = 1;
1475         if (spec->automute_hp_lo) {
1476                 uinfo->value.enumerated.items = 3;
1477                 texts = texts3;
1478         } else {
1479                 uinfo->value.enumerated.items = 2;
1480                 texts = texts2;
1481         }
1482         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1483                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1484         strcpy(uinfo->value.enumerated.name,
1485                texts[uinfo->value.enumerated.item]);
1486         return 0;
1487 }
1488
1489 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
1490                                  struct snd_ctl_elem_value *ucontrol)
1491 {
1492         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1493         struct alc_spec *spec = codec->spec;
1494         unsigned int val;
1495         if (!spec->automute)
1496                 val = 0;
1497         else if (!spec->automute_lines)
1498                 val = 1;
1499         else
1500                 val = 2;
1501         ucontrol->value.enumerated.item[0] = val;
1502         return 0;
1503 }
1504
1505 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
1506                                  struct snd_ctl_elem_value *ucontrol)
1507 {
1508         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1509         struct alc_spec *spec = codec->spec;
1510
1511         switch (ucontrol->value.enumerated.item[0]) {
1512         case 0:
1513                 if (!spec->automute)
1514                         return 0;
1515                 spec->automute = 0;
1516                 break;
1517         case 1:
1518                 if (spec->automute && !spec->automute_lines)
1519                         return 0;
1520                 spec->automute = 1;
1521                 spec->automute_lines = 0;
1522                 break;
1523         case 2:
1524                 if (!spec->automute_hp_lo)
1525                         return -EINVAL;
1526                 if (spec->automute && spec->automute_lines)
1527                         return 0;
1528                 spec->automute = 1;
1529                 spec->automute_lines = 1;
1530                 break;
1531         default:
1532                 return -EINVAL;
1533         }
1534         update_speakers(codec);
1535         return 1;
1536 }
1537
1538 static const struct snd_kcontrol_new alc_automute_mode_enum = {
1539         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1540         .name = "Auto-Mute Mode",
1541         .info = alc_automute_mode_info,
1542         .get = alc_automute_mode_get,
1543         .put = alc_automute_mode_put,
1544 };
1545
1546 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec);
1547
1548 static int alc_add_automute_mode_enum(struct hda_codec *codec)
1549 {
1550         struct alc_spec *spec = codec->spec;
1551         struct snd_kcontrol_new *knew;
1552
1553         knew = alc_kcontrol_new(spec);
1554         if (!knew)
1555                 return -ENOMEM;
1556         *knew = alc_automute_mode_enum;
1557         knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
1558         if (!knew->name)
1559                 return -ENOMEM;
1560         return 0;
1561 }
1562
1563 static void alc_init_auto_hp(struct hda_codec *codec)
1564 {
1565         struct alc_spec *spec = codec->spec;
1566         struct auto_pin_cfg *cfg = &spec->autocfg;
1567         int present = 0;
1568         int i;
1569
1570         if (cfg->hp_pins[0])
1571                 present++;
1572         if (cfg->line_out_pins[0])
1573                 present++;
1574         if (cfg->speaker_pins[0])
1575                 present++;
1576         if (present < 2) /* need two different output types */
1577                 return;
1578         if (present == 3)
1579                 spec->automute_hp_lo = 1; /* both HP and LO automute */
1580
1581         if (!cfg->speaker_pins[0]) {
1582                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1583                        sizeof(cfg->speaker_pins));
1584                 cfg->speaker_outs = cfg->line_outs;
1585         }
1586
1587         if (!cfg->hp_pins[0]) {
1588                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1589                        sizeof(cfg->hp_pins));
1590                 cfg->hp_outs = cfg->line_outs;
1591         }
1592
1593         for (i = 0; i < cfg->hp_outs; i++) {
1594                 hda_nid_t nid = cfg->hp_pins[i];
1595                 if (!is_jack_detectable(codec, nid))
1596                         continue;
1597                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1598                             nid);
1599                 snd_hda_codec_write_cache(codec, nid, 0,
1600                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1601                                   AC_USRSP_EN | ALC880_HP_EVENT);
1602                 spec->automute = 1;
1603                 spec->automute_mode = ALC_AUTOMUTE_PIN;
1604         }
1605         if (spec->automute && cfg->line_out_pins[0] &&
1606             cfg->line_out_pins[0] != cfg->hp_pins[0] &&
1607             cfg->line_out_pins[0] != cfg->speaker_pins[0]) {
1608                 for (i = 0; i < cfg->line_outs; i++) {
1609                         hda_nid_t nid = cfg->line_out_pins[i];
1610                         if (!is_jack_detectable(codec, nid))
1611                                 continue;
1612                         snd_printdd("realtek: Enable Line-Out auto-muting "
1613                                     "on NID 0x%x\n", nid);
1614                         snd_hda_codec_write_cache(codec, nid, 0,
1615                                         AC_VERB_SET_UNSOLICITED_ENABLE,
1616                                         AC_USRSP_EN | ALC880_FRONT_EVENT);
1617                         spec->detect_line = 1;
1618                 }
1619                 spec->automute_lines = spec->detect_line;
1620         }
1621
1622         if (spec->automute) {
1623                 /* create a control for automute mode */
1624                 alc_add_automute_mode_enum(codec);
1625                 spec->unsol_event = alc_sku_unsol_event;
1626         }
1627 }
1628
1629 static void alc_init_auto_mic(struct hda_codec *codec)
1630 {
1631         struct alc_spec *spec = codec->spec;
1632         struct auto_pin_cfg *cfg = &spec->autocfg;
1633         hda_nid_t fixed, ext, dock;
1634         int i;
1635
1636         fixed = ext = dock = 0;
1637         for (i = 0; i < cfg->num_inputs; i++) {
1638                 hda_nid_t nid = cfg->inputs[i].pin;
1639                 unsigned int defcfg;
1640                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1641                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1642                 case INPUT_PIN_ATTR_INT:
1643                         if (fixed)
1644                                 return; /* already occupied */
1645                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1646                                 return; /* invalid type */
1647                         fixed = nid;
1648                         break;
1649                 case INPUT_PIN_ATTR_UNUSED:
1650                         return; /* invalid entry */
1651                 case INPUT_PIN_ATTR_DOCK:
1652                         if (dock)
1653                                 return; /* already occupied */
1654                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1655                                 return; /* invalid type */
1656                         dock = nid;
1657                         break;
1658                 default:
1659                         if (ext)
1660                                 return; /* already occupied */
1661                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1662                                 return; /* invalid type */
1663                         ext = nid;
1664                         break;
1665                 }
1666         }
1667         if (!ext && dock) {
1668                 ext = dock;
1669                 dock = 0;
1670         }
1671         if (!ext || !fixed)
1672                 return;
1673         if (!is_jack_detectable(codec, ext))
1674                 return; /* no unsol support */
1675         if (dock && !is_jack_detectable(codec, dock))
1676                 return; /* no unsol support */
1677         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1678                     ext, fixed, dock);
1679         spec->ext_mic.pin = ext;
1680         spec->dock_mic.pin = dock;
1681         spec->int_mic.pin = fixed;
1682         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1683         spec->dock_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1684         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1685         spec->auto_mic = 1;
1686         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1687                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1688                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1689         spec->unsol_event = alc_sku_unsol_event;
1690 }
1691
1692 /* Could be any non-zero and even value. When used as fixup, tells
1693  * the driver to ignore any present sku defines.
1694  */
1695 #define ALC_FIXUP_SKU_IGNORE (2)
1696
1697 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1698 {
1699         unsigned int ass, tmp, i;
1700         unsigned nid = 0;
1701         struct alc_spec *spec = codec->spec;
1702
1703         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1704
1705         if (spec->cdefine.fixup) {
1706                 ass = spec->cdefine.sku_cfg;
1707                 if (ass == ALC_FIXUP_SKU_IGNORE)
1708                         return -1;
1709                 goto do_sku;
1710         }
1711
1712         ass = codec->subsystem_id & 0xffff;
1713         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1714                 goto do_sku;
1715
1716         nid = 0x1d;
1717         if (codec->vendor_id == 0x10ec0260)
1718                 nid = 0x17;
1719         ass = snd_hda_codec_get_pincfg(codec, nid);
1720
1721         if (!(ass & 1)) {
1722                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1723                        codec->chip_name, ass);
1724                 return -1;
1725         }
1726
1727         /* check sum */
1728         tmp = 0;
1729         for (i = 1; i < 16; i++) {
1730                 if ((ass >> i) & 1)
1731                         tmp++;
1732         }
1733         if (((ass >> 16) & 0xf) != tmp)
1734                 return -1;
1735
1736         spec->cdefine.port_connectivity = ass >> 30;
1737         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1738         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1739         spec->cdefine.customization = ass >> 8;
1740 do_sku:
1741         spec->cdefine.sku_cfg = ass;
1742         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1743         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1744         spec->cdefine.swap = (ass & 0x2) >> 1;
1745         spec->cdefine.override = ass & 0x1;
1746
1747         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1748                    nid, spec->cdefine.sku_cfg);
1749         snd_printd("SKU: port_connectivity=0x%x\n",
1750                    spec->cdefine.port_connectivity);
1751         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1752         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1753         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1754         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1755         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1756         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1757         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1758
1759         return 0;
1760 }
1761
1762 /* check subsystem ID and set up device-specific initialization;
1763  * return 1 if initialized, 0 if invalid SSID
1764  */
1765 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1766  *      31 ~ 16 :       Manufacture ID
1767  *      15 ~ 8  :       SKU ID
1768  *      7  ~ 0  :       Assembly ID
1769  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1770  */
1771 static int alc_subsystem_id(struct hda_codec *codec,
1772                             hda_nid_t porta, hda_nid_t porte,
1773                             hda_nid_t portd, hda_nid_t porti)
1774 {
1775         unsigned int ass, tmp, i;
1776         unsigned nid;
1777         struct alc_spec *spec = codec->spec;
1778
1779         if (spec->cdefine.fixup) {
1780                 ass = spec->cdefine.sku_cfg;
1781                 if (ass == ALC_FIXUP_SKU_IGNORE)
1782                         return 0;
1783                 goto do_sku;
1784         }
1785
1786         ass = codec->subsystem_id & 0xffff;
1787         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1788                 goto do_sku;
1789
1790         /* invalid SSID, check the special NID pin defcfg instead */
1791         /*
1792          * 31~30        : port connectivity
1793          * 29~21        : reserve
1794          * 20           : PCBEEP input
1795          * 19~16        : Check sum (15:1)
1796          * 15~1         : Custom
1797          * 0            : override
1798         */
1799         nid = 0x1d;
1800         if (codec->vendor_id == 0x10ec0260)
1801                 nid = 0x17;
1802         ass = snd_hda_codec_get_pincfg(codec, nid);
1803         snd_printd("realtek: No valid SSID, "
1804                    "checking pincfg 0x%08x for NID 0x%x\n",
1805                    ass, nid);
1806         if (!(ass & 1))
1807                 return 0;
1808         if ((ass >> 30) != 1)   /* no physical connection */
1809                 return 0;
1810
1811         /* check sum */
1812         tmp = 0;
1813         for (i = 1; i < 16; i++) {
1814                 if ((ass >> i) & 1)
1815                         tmp++;
1816         }
1817         if (((ass >> 16) & 0xf) != tmp)
1818                 return 0;
1819 do_sku:
1820         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1821                    ass & 0xffff, codec->vendor_id);
1822         /*
1823          * 0 : override
1824          * 1 :  Swap Jack
1825          * 2 : 0 --> Desktop, 1 --> Laptop
1826          * 3~5 : External Amplifier control
1827          * 7~6 : Reserved
1828         */
1829         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1830         switch (tmp) {
1831         case 1:
1832                 spec->init_amp = ALC_INIT_GPIO1;
1833                 break;
1834         case 3:
1835                 spec->init_amp = ALC_INIT_GPIO2;
1836                 break;
1837         case 7:
1838                 spec->init_amp = ALC_INIT_GPIO3;
1839                 break;
1840         case 5:
1841         default:
1842                 spec->init_amp = ALC_INIT_DEFAULT;
1843                 break;
1844         }
1845
1846         /* is laptop or Desktop and enable the function "Mute internal speaker
1847          * when the external headphone out jack is plugged"
1848          */
1849         if (!(ass & 0x8000))
1850                 return 1;
1851         /*
1852          * 10~8 : Jack location
1853          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1854          * 14~13: Resvered
1855          * 15   : 1 --> enable the function "Mute internal speaker
1856          *              when the external headphone out jack is plugged"
1857          */
1858         if (!spec->autocfg.hp_pins[0]) {
1859                 hda_nid_t nid;
1860                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1861                 if (tmp == 0)
1862                         nid = porta;
1863                 else if (tmp == 1)
1864                         nid = porte;
1865                 else if (tmp == 2)
1866                         nid = portd;
1867                 else if (tmp == 3)
1868                         nid = porti;
1869                 else
1870                         return 1;
1871                 for (i = 0; i < spec->autocfg.line_outs; i++)
1872                         if (spec->autocfg.line_out_pins[i] == nid)
1873                                 return 1;
1874                 spec->autocfg.hp_pins[0] = nid;
1875         }
1876         return 1;
1877 }
1878
1879 static void alc_ssid_check(struct hda_codec *codec,
1880                            hda_nid_t porta, hda_nid_t porte,
1881                            hda_nid_t portd, hda_nid_t porti)
1882 {
1883         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1884                 struct alc_spec *spec = codec->spec;
1885                 snd_printd("realtek: "
1886                            "Enable default setup for auto mode as fallback\n");
1887                 spec->init_amp = ALC_INIT_DEFAULT;
1888         }
1889
1890         alc_init_auto_hp(codec);
1891         alc_init_auto_mic(codec);
1892 }
1893
1894 /*
1895  * Fix-up pin default configurations and add default verbs
1896  */
1897
1898 struct alc_pincfg {
1899         hda_nid_t nid;
1900         u32 val;
1901 };
1902
1903 struct alc_model_fixup {
1904         const int id;
1905         const char *name;
1906 };
1907
1908 struct alc_fixup {
1909         int type;
1910         bool chained;
1911         int chain_id;
1912         union {
1913                 unsigned int sku;
1914                 const struct alc_pincfg *pins;
1915                 const struct hda_verb *verbs;
1916                 void (*func)(struct hda_codec *codec,
1917                              const struct alc_fixup *fix,
1918                              int action);
1919         } v;
1920 };
1921
1922 enum {
1923         ALC_FIXUP_INVALID,
1924         ALC_FIXUP_SKU,
1925         ALC_FIXUP_PINS,
1926         ALC_FIXUP_VERBS,
1927         ALC_FIXUP_FUNC,
1928 };
1929
1930 enum {
1931         ALC_FIXUP_ACT_PRE_PROBE,
1932         ALC_FIXUP_ACT_PROBE,
1933         ALC_FIXUP_ACT_INIT,
1934 };
1935
1936 static void alc_apply_fixup(struct hda_codec *codec, int action)
1937 {
1938         struct alc_spec *spec = codec->spec;
1939         int id = spec->fixup_id;
1940 #ifdef CONFIG_SND_DEBUG_VERBOSE
1941         const char *modelname = spec->fixup_name;
1942 #endif
1943         int depth = 0;
1944
1945         if (!spec->fixup_list)
1946                 return;
1947
1948         while (id >= 0) {
1949                 const struct alc_fixup *fix = spec->fixup_list + id;
1950                 const struct alc_pincfg *cfg;
1951
1952                 switch (fix->type) {
1953                 case ALC_FIXUP_SKU:
1954                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1955                                 break;;
1956                         snd_printdd(KERN_INFO "hda_codec: %s: "
1957                                     "Apply sku override for %s\n",
1958                                     codec->chip_name, modelname);
1959                         spec->cdefine.sku_cfg = fix->v.sku;
1960                         spec->cdefine.fixup = 1;
1961                         break;
1962                 case ALC_FIXUP_PINS:
1963                         cfg = fix->v.pins;
1964                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1965                                 break;
1966                         snd_printdd(KERN_INFO "hda_codec: %s: "
1967                                     "Apply pincfg for %s\n",
1968                                     codec->chip_name, modelname);
1969                         for (; cfg->nid; cfg++)
1970                                 snd_hda_codec_set_pincfg(codec, cfg->nid,
1971                                                          cfg->val);
1972                         break;
1973                 case ALC_FIXUP_VERBS:
1974                         if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1975                                 break;
1976                         snd_printdd(KERN_INFO "hda_codec: %s: "
1977                                     "Apply fix-verbs for %s\n",
1978                                     codec->chip_name, modelname);
1979                         add_verb(codec->spec, fix->v.verbs);
1980                         break;
1981                 case ALC_FIXUP_FUNC:
1982                         if (!fix->v.func)
1983                                 break;
1984                         snd_printdd(KERN_INFO "hda_codec: %s: "
1985                                     "Apply fix-func for %s\n",
1986                                     codec->chip_name, modelname);
1987                         fix->v.func(codec, fix, action);
1988                         break;
1989                 default:
1990                         snd_printk(KERN_ERR "hda_codec: %s: "
1991                                    "Invalid fixup type %d\n",
1992                                    codec->chip_name, fix->type);
1993                         break;
1994                 }
1995                 if (!fix->chained)
1996                         break;
1997                 if (++depth > 10)
1998                         break;
1999                 id = fix->chain_id;
2000         }
2001 }
2002
2003 static void alc_pick_fixup(struct hda_codec *codec,
2004                            const struct alc_model_fixup *models,
2005                            const struct snd_pci_quirk *quirk,
2006                            const struct alc_fixup *fixlist)
2007 {
2008         struct alc_spec *spec = codec->spec;
2009         int id = -1;
2010         const char *name = NULL;
2011
2012         if (codec->modelname && models) {
2013                 while (models->name) {
2014                         if (!strcmp(codec->modelname, models->name)) {
2015                                 id = models->id;
2016                                 name = models->name;
2017                                 break;
2018                         }
2019                         models++;
2020                 }
2021         }
2022         if (id < 0) {
2023                 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
2024                 if (quirk) {
2025                         id = quirk->value;
2026 #ifdef CONFIG_SND_DEBUG_VERBOSE
2027                         name = quirk->name;
2028 #endif
2029                 }
2030         }
2031
2032         spec->fixup_id = id;
2033         if (id >= 0) {
2034                 spec->fixup_list = fixlist;
2035                 spec->fixup_name = name;
2036         }
2037 }
2038
2039 static int alc_read_coef_idx(struct hda_codec *codec,
2040                         unsigned int coef_idx)
2041 {
2042         unsigned int val;
2043         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
2044                                 coef_idx);
2045         val = snd_hda_codec_read(codec, 0x20, 0,
2046                                 AC_VERB_GET_PROC_COEF, 0);
2047         return val;
2048 }
2049
2050 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
2051                                                         unsigned int coef_val)
2052 {
2053         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
2054                             coef_idx);
2055         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
2056                             coef_val);
2057 }
2058
2059 /* set right pin controls for digital I/O */
2060 static void alc_auto_init_digital(struct hda_codec *codec)
2061 {
2062         struct alc_spec *spec = codec->spec;
2063         int i;
2064         hda_nid_t pin;
2065
2066         for (i = 0; i < spec->autocfg.dig_outs; i++) {
2067                 pin = spec->autocfg.dig_out_pins[i];
2068                 if (pin) {
2069                         snd_hda_codec_write(codec, pin, 0,
2070                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
2071                                             PIN_OUT);
2072                 }
2073         }
2074         pin = spec->autocfg.dig_in_pin;
2075         if (pin)
2076                 snd_hda_codec_write(codec, pin, 0,
2077                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
2078                                     PIN_IN);
2079 }
2080
2081 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
2082 static void alc_auto_parse_digital(struct hda_codec *codec)
2083 {
2084         struct alc_spec *spec = codec->spec;
2085         int i, err;
2086         hda_nid_t dig_nid;
2087
2088         /* support multiple SPDIFs; the secondary is set up as a slave */
2089         for (i = 0; i < spec->autocfg.dig_outs; i++) {
2090                 err = snd_hda_get_connections(codec,
2091                                               spec->autocfg.dig_out_pins[i],
2092                                               &dig_nid, 1);
2093                 if (err < 0)
2094                         continue;
2095                 if (!i) {
2096                         spec->multiout.dig_out_nid = dig_nid;
2097                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
2098                 } else {
2099                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
2100                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
2101                                 break;
2102                         spec->slave_dig_outs[i - 1] = dig_nid;
2103                 }
2104         }
2105
2106         if (spec->autocfg.dig_in_pin) {
2107                 dig_nid = codec->start_nid;
2108                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
2109                         unsigned int wcaps = get_wcaps(codec, dig_nid);
2110                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2111                                 continue;
2112                         if (!(wcaps & AC_WCAP_DIGITAL))
2113                                 continue;
2114                         if (!(wcaps & AC_WCAP_CONN_LIST))
2115                                 continue;
2116                         err = get_connection_index(codec, dig_nid,
2117                                                    spec->autocfg.dig_in_pin);
2118                         if (err >= 0) {
2119                                 spec->dig_in_nid = dig_nid;
2120                                 break;
2121                         }
2122                 }
2123         }
2124 }
2125
2126 /*
2127  * ALC888
2128  */
2129
2130 /*
2131  * 2ch mode
2132  */
2133 static const struct hda_verb alc888_4ST_ch2_intel_init[] = {
2134 /* Mic-in jack as mic in */
2135         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2136         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2137 /* Line-in jack as Line in */
2138         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2139         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2140 /* Line-Out as Front */
2141         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
2142         { } /* end */
2143 };
2144
2145 /*
2146  * 4ch mode
2147  */
2148 static const struct hda_verb alc888_4ST_ch4_intel_init[] = {
2149 /* Mic-in jack as mic in */
2150         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2151         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2152 /* Line-in jack as Surround */
2153         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2154         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2155 /* Line-Out as Front */
2156         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
2157         { } /* end */
2158 };
2159
2160 /*
2161  * 6ch mode
2162  */
2163 static const struct hda_verb alc888_4ST_ch6_intel_init[] = {
2164 /* Mic-in jack as CLFE */
2165         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2166         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2167 /* Line-in jack as Surround */
2168         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2169         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2170 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
2171         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2172         { } /* end */
2173 };
2174
2175 /*
2176  * 8ch mode
2177  */
2178 static const struct hda_verb alc888_4ST_ch8_intel_init[] = {
2179 /* Mic-in jack as CLFE */
2180         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2181         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2182 /* Line-in jack as Surround */
2183         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2184         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2185 /* Line-Out as Side */
2186         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2187         { } /* end */
2188 };
2189
2190 static const struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
2191         { 2, alc888_4ST_ch2_intel_init },
2192         { 4, alc888_4ST_ch4_intel_init },
2193         { 6, alc888_4ST_ch6_intel_init },
2194         { 8, alc888_4ST_ch8_intel_init },
2195 };
2196
2197 /*
2198  * ALC888 Fujitsu Siemens Amillo xa3530
2199  */
2200
2201 static const struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
2202 /* Front Mic: set to PIN_IN (empty by default) */
2203         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2204 /* Connect Internal HP to Front */
2205         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2206         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2207         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2208 /* Connect Bass HP to Front */
2209         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2210         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2211         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2212 /* Connect Line-Out side jack (SPDIF) to Side */
2213         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2214         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2215         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2216 /* Connect Mic jack to CLFE */
2217         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2218         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2219         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
2220 /* Connect Line-in jack to Surround */
2221         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2222         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2223         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
2224 /* Connect HP out jack to Front */
2225         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2226         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2227         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2228 /* Enable unsolicited event for HP jack and Line-out jack */
2229         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2230         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2231         {}
2232 };
2233
2234 static void alc889_automute_setup(struct hda_codec *codec)
2235 {
2236         struct alc_spec *spec = codec->spec;
2237
2238         spec->autocfg.hp_pins[0] = 0x15;
2239         spec->autocfg.speaker_pins[0] = 0x14;
2240         spec->autocfg.speaker_pins[1] = 0x16;
2241         spec->autocfg.speaker_pins[2] = 0x17;
2242         spec->autocfg.speaker_pins[3] = 0x19;
2243         spec->autocfg.speaker_pins[4] = 0x1a;
2244         spec->automute = 1;
2245         spec->automute_mode = ALC_AUTOMUTE_AMP;
2246 }
2247
2248 static void alc889_intel_init_hook(struct hda_codec *codec)
2249 {
2250         alc889_coef_init(codec);
2251         alc_hp_automute(codec);
2252 }
2253
2254 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
2255 {
2256         struct alc_spec *spec = codec->spec;
2257
2258         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
2259         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
2260         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
2261         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
2262         spec->automute = 1;
2263         spec->automute_mode = ALC_AUTOMUTE_AMP;
2264 }
2265
2266 /*
2267  * ALC888 Acer Aspire 4930G model
2268  */
2269
2270 static const struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
2271 /* Front Mic: set to PIN_IN (empty by default) */
2272         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2273 /* Unselect Front Mic by default in input mixer 3 */
2274         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2275 /* Enable unsolicited event for HP jack */
2276         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2277 /* Connect Internal HP to front */
2278         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2279         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2280         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2281 /* Connect HP out to front */
2282         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2283         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2284         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2285         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2286         { }
2287 };
2288
2289 /*
2290  * ALC888 Acer Aspire 6530G model
2291  */
2292
2293 static const struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2294 /* Route to built-in subwoofer as well as speakers */
2295         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2296         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2297         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2298         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2299 /* Bias voltage on for external mic port */
2300         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2301 /* Front Mic: set to PIN_IN (empty by default) */
2302         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2303 /* Unselect Front Mic by default in input mixer 3 */
2304         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2305 /* Enable unsolicited event for HP jack */
2306         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2307 /* Enable speaker output */
2308         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2309         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2310         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2311 /* Enable headphone output */
2312         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2313         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2314         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2315         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2316         { }
2317 };
2318
2319 /*
2320  *ALC888 Acer Aspire 7730G model
2321  */
2322
2323 static const struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2324 /* Bias voltage on for external mic port */
2325         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2326 /* Front Mic: set to PIN_IN (empty by default) */
2327         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2328 /* Unselect Front Mic by default in input mixer 3 */
2329         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2330 /* Enable unsolicited event for HP jack */
2331         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2332 /* Enable speaker output */
2333         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2334         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2335         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2336 /* Enable headphone output */
2337         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2338         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2339         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2340         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2341 /*Enable internal subwoofer */
2342         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2343         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2344         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2345         {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2346         { }
2347 };
2348
2349 /*
2350  * ALC889 Acer Aspire 8930G model
2351  */
2352
2353 static const struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2354 /* Front Mic: set to PIN_IN (empty by default) */
2355         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2356 /* Unselect Front Mic by default in input mixer 3 */
2357         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2358 /* Enable unsolicited event for HP jack */
2359         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2360 /* Connect Internal Front to Front */
2361         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2362         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2363         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2364 /* Connect Internal Rear to Rear */
2365         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2366         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2367         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2368 /* Connect Internal CLFE to CLFE */
2369         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2370         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2371         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2372 /* Connect HP out to Front */
2373         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2374         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2375         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2376 /* Enable all DACs */
2377 /*  DAC DISABLE/MUTE 1? */
2378 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2379         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2380         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2381 /*  DAC DISABLE/MUTE 2? */
2382 /*  some bit here disables the other DACs. Init=0x4900 */
2383         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2384         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2385 /* DMIC fix
2386  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2387  * which makes the stereo useless. However, either the mic or the ALC889
2388  * makes the signal become a difference/sum signal instead of standard
2389  * stereo, which is annoying. So instead we flip this bit which makes the
2390  * codec replicate the sum signal to both channels, turning it into a
2391  * normal mono mic.
2392  */
2393 /*  DMIC_CONTROL? Init value = 0x0001 */
2394         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2395         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2396         { }
2397 };
2398
2399 static const struct hda_input_mux alc888_2_capture_sources[2] = {
2400         /* Front mic only available on one ADC */
2401         {
2402                 .num_items = 4,
2403                 .items = {
2404                         { "Mic", 0x0 },
2405                         { "Line", 0x2 },
2406                         { "CD", 0x4 },
2407                         { "Front Mic", 0xb },
2408                 },
2409         },
2410         {
2411                 .num_items = 3,
2412                 .items = {
2413                         { "Mic", 0x0 },
2414                         { "Line", 0x2 },
2415                         { "CD", 0x4 },
2416                 },
2417         }
2418 };
2419
2420 static const struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2421         /* Interal mic only available on one ADC */
2422         {
2423                 .num_items = 5,
2424                 .items = {
2425                         { "Mic", 0x0 },
2426                         { "Line In", 0x2 },
2427                         { "CD", 0x4 },
2428                         { "Input Mix", 0xa },
2429                         { "Internal Mic", 0xb },
2430                 },
2431         },
2432         {
2433                 .num_items = 4,
2434                 .items = {
2435                         { "Mic", 0x0 },
2436                         { "Line In", 0x2 },
2437                         { "CD", 0x4 },
2438                         { "Input Mix", 0xa },
2439                 },
2440         }
2441 };
2442
2443 static const struct hda_input_mux alc889_capture_sources[3] = {
2444         /* Digital mic only available on first "ADC" */
2445         {
2446                 .num_items = 5,
2447                 .items = {
2448                         { "Mic", 0x0 },
2449                         { "Line", 0x2 },
2450                         { "CD", 0x4 },
2451                         { "Front Mic", 0xb },
2452                         { "Input Mix", 0xa },
2453                 },
2454         },
2455         {
2456                 .num_items = 4,
2457                 .items = {
2458                         { "Mic", 0x0 },
2459                         { "Line", 0x2 },
2460                         { "CD", 0x4 },
2461                         { "Input Mix", 0xa },
2462                 },
2463         },
2464         {
2465                 .num_items = 4,
2466                 .items = {
2467                         { "Mic", 0x0 },
2468                         { "Line", 0x2 },
2469                         { "CD", 0x4 },
2470                         { "Input Mix", 0xa },
2471                 },
2472         }
2473 };
2474
2475 static const struct snd_kcontrol_new alc888_base_mixer[] = {
2476         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2477         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2478         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2479         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2480         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2481                 HDA_OUTPUT),
2482         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2483         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2484         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2485         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2486         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2487         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2488         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2489         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2490         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2491         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2492         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2493         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2494         { } /* end */
2495 };
2496
2497 static const struct snd_kcontrol_new alc888_acer_aspire_4930g_mixer[] = {
2498         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2499         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2500         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2501         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2502         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2503                 HDA_OUTPUT),
2504         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2505         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2506         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2507         HDA_CODEC_VOLUME_MONO("Internal LFE Playback Volume", 0x0f, 1, 0x0, HDA_OUTPUT),
2508         HDA_BIND_MUTE_MONO("Internal LFE Playback Switch", 0x0f, 1, 2, HDA_INPUT),
2509         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2510         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2511         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2512         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2513         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2514         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2515         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2516         { } /* end */
2517 };
2518
2519 static const struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2520         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2521         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2522         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2523         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2524         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2525                 HDA_OUTPUT),
2526         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2527         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2528         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2529         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2530         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2531         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2532         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2533         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2534         { } /* end */
2535 };
2536
2537
2538 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2539 {
2540         struct alc_spec *spec = codec->spec;
2541
2542         spec->autocfg.hp_pins[0] = 0x15;
2543         spec->autocfg.speaker_pins[0] = 0x14;
2544         spec->autocfg.speaker_pins[1] = 0x16;
2545         spec->autocfg.speaker_pins[2] = 0x17;
2546         spec->automute = 1;
2547         spec->automute_mode = ALC_AUTOMUTE_AMP;
2548 }
2549
2550 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2551 {
2552         struct alc_spec *spec = codec->spec;
2553
2554         spec->autocfg.hp_pins[0] = 0x15;
2555         spec->autocfg.speaker_pins[0] = 0x14;
2556         spec->autocfg.speaker_pins[1] = 0x16;
2557         spec->autocfg.speaker_pins[2] = 0x17;
2558         spec->automute = 1;
2559         spec->automute_mode = ALC_AUTOMUTE_AMP;
2560 }
2561
2562 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2563 {
2564         struct alc_spec *spec = codec->spec;
2565
2566         spec->autocfg.hp_pins[0] = 0x15;
2567         spec->autocfg.speaker_pins[0] = 0x14;
2568         spec->autocfg.speaker_pins[1] = 0x16;
2569         spec->autocfg.speaker_pins[2] = 0x17;
2570         spec->automute = 1;
2571         spec->automute_mode = ALC_AUTOMUTE_AMP;
2572 }
2573
2574 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2575 {
2576         struct alc_spec *spec = codec->spec;
2577
2578         spec->autocfg.hp_pins[0] = 0x15;
2579         spec->autocfg.speaker_pins[0] = 0x14;
2580         spec->autocfg.speaker_pins[1] = 0x16;
2581         spec->autocfg.speaker_pins[2] = 0x1b;
2582         spec->automute = 1;
2583         spec->automute_mode = ALC_AUTOMUTE_AMP;
2584 }
2585
2586 /*
2587  * ALC880 3-stack model
2588  *
2589  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2590  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2591  *                 F-Mic = 0x1b, HP = 0x19
2592  */
2593
2594 static const hda_nid_t alc880_dac_nids[4] = {
2595         /* front, rear, clfe, rear_surr */
2596         0x02, 0x05, 0x04, 0x03
2597 };
2598
2599 static const hda_nid_t alc880_adc_nids[3] = {
2600         /* ADC0-2 */
2601         0x07, 0x08, 0x09,
2602 };
2603
2604 /* The datasheet says the node 0x07 is connected from inputs,
2605  * but it shows zero connection in the real implementation on some devices.
2606  * Note: this is a 915GAV bug, fixed on 915GLV
2607  */
2608 static const hda_nid_t alc880_adc_nids_alt[2] = {
2609         /* ADC1-2 */
2610         0x08, 0x09,
2611 };
2612
2613 #define ALC880_DIGOUT_NID       0x06
2614 #define ALC880_DIGIN_NID        0x0a
2615
2616 static const struct hda_input_mux alc880_capture_source = {
2617         .num_items = 4,
2618         .items = {
2619                 { "Mic", 0x0 },
2620                 { "Front Mic", 0x3 },
2621                 { "Line", 0x2 },
2622                 { "CD", 0x4 },
2623         },
2624 };
2625
2626 /* channel source setting (2/6 channel selection for 3-stack) */
2627 /* 2ch mode */
2628 static const struct hda_verb alc880_threestack_ch2_init[] = {
2629         /* set line-in to input, mute it */
2630         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2631         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2632         /* set mic-in to input vref 80%, mute it */
2633         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2634         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2635         { } /* end */
2636 };
2637
2638 /* 6ch mode */
2639 static const struct hda_verb alc880_threestack_ch6_init[] = {
2640         /* set line-in to output, unmute it */
2641         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2642         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2643         /* set mic-in to output, unmute it */
2644         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2645         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2646         { } /* end */
2647 };
2648
2649 static const struct hda_channel_mode alc880_threestack_modes[2] = {
2650         { 2, alc880_threestack_ch2_init },
2651         { 6, alc880_threestack_ch6_init },
2652 };
2653
2654 static const struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2655         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2656         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2657         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2658         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2659         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2660         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2661         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2662         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2663         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2664         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2665         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2666         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2667         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2668         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2669         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2670         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2671         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2672         {
2673                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2674                 .name = "Channel Mode",
2675                 .info = alc_ch_mode_info,
2676                 .get = alc_ch_mode_get,
2677                 .put = alc_ch_mode_put,
2678         },
2679         { } /* end */
2680 };
2681
2682 /* capture mixer elements */
2683 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2684                             struct snd_ctl_elem_info *uinfo)
2685 {
2686         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2687         struct alc_spec *spec = codec->spec;
2688         int err;
2689
2690         mutex_lock(&codec->control_mutex);
2691         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2692                                                       HDA_INPUT);
2693         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2694         mutex_unlock(&codec->control_mutex);
2695         return err;
2696 }
2697
2698 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2699                            unsigned int size, unsigned int __user *tlv)
2700 {
2701         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2702         struct alc_spec *spec = codec->spec;
2703         int err;
2704
2705         mutex_lock(&codec->control_mutex);
2706         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2707                                                       HDA_INPUT);
2708         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2709         mutex_unlock(&codec->control_mutex);
2710         return err;
2711 }
2712
2713 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2714                              struct snd_ctl_elem_value *ucontrol);
2715
2716 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2717                                  struct snd_ctl_elem_value *ucontrol,
2718                                  getput_call_t func)
2719 {
2720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2721         struct alc_spec *spec = codec->spec;
2722         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2723         int err;
2724
2725         mutex_lock(&codec->control_mutex);
2726         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2727                                                       3, 0, HDA_INPUT);
2728         err = func(kcontrol, ucontrol);
2729         mutex_unlock(&codec->control_mutex);
2730         return err;
2731 }
2732
2733 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2734                            struct snd_ctl_elem_value *ucontrol)
2735 {
2736         return alc_cap_getput_caller(kcontrol, ucontrol,
2737                                      snd_hda_mixer_amp_volume_get);
2738 }
2739
2740 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2741                            struct snd_ctl_elem_value *ucontrol)
2742 {
2743         return alc_cap_getput_caller(kcontrol, ucontrol,
2744                                      snd_hda_mixer_amp_volume_put);
2745 }
2746
2747 /* capture mixer elements */
2748 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2749
2750 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2751                           struct snd_ctl_elem_value *ucontrol)
2752 {
2753         return alc_cap_getput_caller(kcontrol, ucontrol,
2754                                      snd_hda_mixer_amp_switch_get);
2755 }
2756
2757 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2758                           struct snd_ctl_elem_value *ucontrol)
2759 {
2760         return alc_cap_getput_caller(kcontrol, ucontrol,
2761                                      snd_hda_mixer_amp_switch_put);
2762 }
2763
2764 #define _DEFINE_CAPMIX(num) \
2765         { \
2766                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2767                 .name = "Capture Switch", \
2768                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2769                 .count = num, \
2770                 .info = alc_cap_sw_info, \
2771                 .get = alc_cap_sw_get, \
2772                 .put = alc_cap_sw_put, \
2773         }, \
2774         { \
2775                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2776                 .name = "Capture Volume", \
2777                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2778                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2779                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2780                 .count = num, \
2781                 .info = alc_cap_vol_info, \
2782                 .get = alc_cap_vol_get, \
2783                 .put = alc_cap_vol_put, \
2784                 .tlv = { .c = alc_cap_vol_tlv }, \
2785         }
2786
2787 #define _DEFINE_CAPSRC(num) \
2788         { \
2789                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2790                 /* .name = "Capture Source", */ \
2791                 .name = "Input Source", \
2792                 .count = num, \
2793                 .info = alc_mux_enum_info, \
2794                 .get = alc_mux_enum_get, \
2795                 .put = alc_mux_enum_put, \
2796         }
2797
2798 #define DEFINE_CAPMIX(num) \
2799 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2800         _DEFINE_CAPMIX(num),                                  \
2801         _DEFINE_CAPSRC(num),                                  \
2802         { } /* end */                                         \
2803 }
2804
2805 #define DEFINE_CAPMIX_NOSRC(num) \
2806 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2807         _DEFINE_CAPMIX(num),                                        \
2808         { } /* end */                                               \
2809 }
2810
2811 /* up to three ADCs */
2812 DEFINE_CAPMIX(1);
2813 DEFINE_CAPMIX(2);
2814 DEFINE_CAPMIX(3);
2815 DEFINE_CAPMIX_NOSRC(1);
2816 DEFINE_CAPMIX_NOSRC(2);
2817 DEFINE_CAPMIX_NOSRC(3);
2818
2819 /*
2820  * ALC880 5-stack model
2821  *
2822  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2823  *      Side = 0x02 (0xd)
2824  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2825  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2826  */
2827
2828 /* additional mixers to alc880_three_stack_mixer */
2829 static const struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2830         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2831         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2832         { } /* end */
2833 };
2834
2835 /* channel source setting (6/8 channel selection for 5-stack) */
2836 /* 6ch mode */
2837 static const struct hda_verb alc880_fivestack_ch6_init[] = {
2838         /* set line-in to input, mute it */
2839         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2840         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2841         { } /* end */
2842 };
2843
2844 /* 8ch mode */
2845 static const struct hda_verb alc880_fivestack_ch8_init[] = {
2846         /* set line-in to output, unmute it */
2847         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2848         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2849         { } /* end */
2850 };
2851
2852 static const struct hda_channel_mode alc880_fivestack_modes[2] = {
2853         { 6, alc880_fivestack_ch6_init },
2854         { 8, alc880_fivestack_ch8_init },
2855 };
2856
2857
2858 /*
2859  * ALC880 6-stack model
2860  *
2861  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2862  *      Side = 0x05 (0x0f)
2863  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2864  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2865  */
2866
2867 static const hda_nid_t alc880_6st_dac_nids[4] = {
2868         /* front, rear, clfe, rear_surr */
2869         0x02, 0x03, 0x04, 0x05
2870 };
2871
2872 static const struct hda_input_mux alc880_6stack_capture_source = {
2873         .num_items = 4,
2874         .items = {
2875                 { "Mic", 0x0 },
2876                 { "Front Mic", 0x1 },
2877                 { "Line", 0x2 },
2878                 { "CD", 0x4 },
2879         },
2880 };
2881
2882 /* fixed 8-channels */
2883 static const struct hda_channel_mode alc880_sixstack_modes[1] = {
2884         { 8, NULL },
2885 };
2886
2887 static const struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2888         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2889         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2890         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2891         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2892         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2893         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2894         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2895         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2896         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2897         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2898         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2899         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2902         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2903         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2904         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2905         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2906         {
2907                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2908                 .name = "Channel Mode",
2909                 .info = alc_ch_mode_info,
2910                 .get = alc_ch_mode_get,
2911                 .put = alc_ch_mode_put,
2912         },
2913         { } /* end */
2914 };
2915
2916
2917 /*
2918  * ALC880 W810 model
2919  *
2920  * W810 has rear IO for:
2921  * Front (DAC 02)
2922  * Surround (DAC 03)
2923  * Center/LFE (DAC 04)
2924  * Digital out (06)
2925  *
2926  * The system also has a pair of internal speakers, and a headphone jack.
2927  * These are both connected to Line2 on the codec, hence to DAC 02.
2928  *
2929  * There is a variable resistor to control the speaker or headphone
2930  * volume. This is a hardware-only device without a software API.
2931  *
2932  * Plugging headphones in will disable the internal speakers. This is
2933  * implemented in hardware, not via the driver using jack sense. In
2934  * a similar fashion, plugging into the rear socket marked "front" will
2935  * disable both the speakers and headphones.
2936  *
2937  * For input, there's a microphone jack, and an "audio in" jack.
2938  * These may not do anything useful with this driver yet, because I
2939  * haven't setup any initialization verbs for these yet...
2940  */
2941
2942 static const hda_nid_t alc880_w810_dac_nids[3] = {
2943         /* front, rear/surround, clfe */
2944         0x02, 0x03, 0x04
2945 };
2946
2947 /* fixed 6 channels */
2948 static const struct hda_channel_mode alc880_w810_modes[1] = {
2949         { 6, NULL }
2950 };
2951
2952 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2953 static const struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2954         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2955         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2956         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2957         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2958         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2959         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2960         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2961         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2962         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2963         { } /* end */
2964 };
2965
2966
2967 /*
2968  * Z710V model
2969  *
2970  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2971  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2972  *                 Line = 0x1a
2973  */
2974
2975 static const hda_nid_t alc880_z71v_dac_nids[1] = {
2976         0x02
2977 };
2978 #define ALC880_Z71V_HP_DAC      0x03
2979
2980 /* fixed 2 channels */
2981 static const struct hda_channel_mode alc880_2_jack_modes[1] = {
2982         { 2, NULL }
2983 };
2984
2985 static const struct snd_kcontrol_new alc880_z71v_mixer[] = {
2986         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2987         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2988         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2989         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2990         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2991         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2992         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2993         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2994         { } /* end */
2995 };
2996
2997
2998 /*
2999  * ALC880 F1734 model
3000  *
3001  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
3002  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
3003  */
3004
3005 static const hda_nid_t alc880_f1734_dac_nids[1] = {
3006         0x03
3007 };
3008 #define ALC880_F1734_HP_DAC     0x02
3009
3010 static const struct snd_kcontrol_new alc880_f1734_mixer[] = {
3011         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3012         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3013         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3014         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3015         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3016         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3017         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3018         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3019         { } /* end */
3020 };
3021
3022 static const struct hda_input_mux alc880_f1734_capture_source = {
3023         .num_items = 2,
3024         .items = {
3025                 { "Mic", 0x1 },
3026                 { "CD", 0x4 },
3027         },
3028 };
3029
3030
3031 /*
3032  * ALC880 ASUS model
3033  *
3034  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
3035  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
3036  *  Mic = 0x18, Line = 0x1a
3037  */
3038
3039 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
3040 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
3041
3042 static const struct snd_kcontrol_new alc880_asus_mixer[] = {
3043         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3044         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3045         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3046         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3047         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3048         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3049         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3050         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3051         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3052         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3053         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3054         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3055         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3056         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3057         {
3058                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3059                 .name = "Channel Mode",
3060                 .info = alc_ch_mode_info,
3061                 .get = alc_ch_mode_get,
3062                 .put = alc_ch_mode_put,
3063         },
3064         { } /* end */
3065 };
3066
3067 /*
3068  * ALC880 ASUS W1V model
3069  *
3070  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
3071  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
3072  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
3073  */
3074
3075 /* additional mixers to alc880_asus_mixer */
3076 static const struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
3077         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
3078         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
3079         { } /* end */
3080 };
3081
3082 /* TCL S700 */
3083 static const struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
3084         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3085         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
3086         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
3087         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
3088         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
3089         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
3090         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
3091         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
3092         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
3093         { } /* end */
3094 };
3095
3096 /* Uniwill */
3097 static const struct snd_kcontrol_new alc880_uniwill_mixer[] = {
3098         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3099         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3100         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3101         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3102         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3103         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3104         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3105         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3106         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3107         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3108         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3109         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3110         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3111         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3112         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3113         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3114         {
3115                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3116                 .name = "Channel Mode",
3117                 .info = alc_ch_mode_info,
3118                 .get = alc_ch_mode_get,
3119                 .put = alc_ch_mode_put,
3120         },
3121         { } /* end */
3122 };
3123
3124 static const struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
3125         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3126         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3127         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3128         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3129         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3130         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3131         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3132         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3133         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3134         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3135         { } /* end */
3136 };
3137
3138 static const struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
3139         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3140         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3141         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3142         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3143         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3144         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3145         { } /* end */
3146 };
3147
3148 /*
3149  * virtual master controls
3150  */
3151
3152 /*
3153  * slave controls for virtual master
3154  */
3155 static const char * const alc_slave_vols[] = {
3156         "Front Playback Volume",
3157         "Surround Playback Volume",
3158         "Center Playback Volume",
3159         "LFE Playback Volume",
3160         "Side Playback Volume",
3161         "Headphone Playback Volume",
3162         "Speaker Playback Volume",
3163         "Mono Playback Volume",
3164         "Line-Out Playback Volume",
3165         NULL,
3166 };
3167
3168 static const char * const alc_slave_sws[] = {
3169         "Front Playback Switch",
3170         "Surround Playback Switch",
3171         "Center Playback Switch",
3172         "LFE Playback Switch",
3173         "Side Playback Switch",
3174         "Headphone Playback Switch",
3175         "Speaker Playback Switch",
3176         "Mono Playback Switch",
3177         "IEC958 Playback Switch",
3178         "Line-Out Playback Switch",
3179         NULL,
3180 };
3181
3182 /*
3183  * build control elements
3184  */
3185
3186 #define NID_MAPPING             (-1)
3187
3188 #define SUBDEV_SPEAKER_         (0 << 6)
3189 #define SUBDEV_HP_              (1 << 6)
3190 #define SUBDEV_LINE_            (2 << 6)
3191 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
3192 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
3193 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
3194
3195 static void alc_free_kctls(struct hda_codec *codec);
3196
3197 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3198 /* additional beep mixers; the actual parameters are overwritten at build */
3199 static const struct snd_kcontrol_new alc_beep_mixer[] = {
3200         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
3201         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
3202         { } /* end */
3203 };
3204 #endif
3205
3206 static int alc_build_controls(struct hda_codec *codec)
3207 {
3208         struct alc_spec *spec = codec->spec;
3209         struct snd_kcontrol *kctl = NULL;
3210         const struct snd_kcontrol_new *knew;
3211         int i, j, err;
3212         unsigned int u;
3213         hda_nid_t nid;
3214
3215         for (i = 0; i < spec->num_mixers; i++) {
3216                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
3217                 if (err < 0)
3218                         return err;
3219         }
3220         if (spec->cap_mixer) {
3221                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
3222                 if (err < 0)
3223                         return err;
3224         }
3225         if (spec->multiout.dig_out_nid) {
3226                 err = snd_hda_create_spdif_out_ctls(codec,
3227                                                     spec->multiout.dig_out_nid,
3228                                                     spec->multiout.dig_out_nid);
3229                 if (err < 0)
3230                         return err;
3231                 if (!spec->no_analog) {
3232                         err = snd_hda_create_spdif_share_sw(codec,
3233                                                             &spec->multiout);
3234                         if (err < 0)
3235                                 return err;
3236                         spec->multiout.share_spdif = 1;
3237                 }
3238         }
3239         if (spec->dig_in_nid) {
3240                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3241                 if (err < 0)
3242                         return err;
3243         }
3244
3245 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3246         /* create beep controls if needed */
3247         if (spec->beep_amp) {
3248                 const struct snd_kcontrol_new *knew;
3249                 for (knew = alc_beep_mixer; knew->name; knew++) {
3250                         struct snd_kcontrol *kctl;
3251                         kctl = snd_ctl_new1(knew, codec);
3252                         if (!kctl)
3253                                 return -ENOMEM;
3254                         kctl->private_value = spec->beep_amp;
3255                         err = snd_hda_ctl_add(codec, 0, kctl);
3256                         if (err < 0)
3257                                 return err;
3258                 }
3259         }
3260 #endif
3261
3262         /* if we have no master control, let's create it */
3263         if (!spec->no_analog &&
3264             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3265                 unsigned int vmaster_tlv[4];
3266                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3267                                         HDA_OUTPUT, vmaster_tlv);
3268                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3269                                           vmaster_tlv, alc_slave_vols);
3270                 if (err < 0)
3271                         return err;
3272         }
3273         if (!spec->no_analog &&
3274             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3275                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
3276                                           NULL, alc_slave_sws);
3277                 if (err < 0)
3278                         return err;
3279         }
3280
3281         /* assign Capture Source enums to NID */
3282         if (spec->capsrc_nids || spec->adc_nids) {
3283                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
3284                 if (!kctl)
3285                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3286                 for (i = 0; kctl && i < kctl->count; i++) {
3287                         const hda_nid_t *nids = spec->capsrc_nids;
3288                         if (!nids)
3289                                 nids = spec->adc_nids;
3290                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3291                         if (err < 0)
3292                                 return err;
3293                 }
3294         }
3295         if (spec->cap_mixer) {
3296                 const char *kname = kctl ? kctl->id.name : NULL;
3297                 for (knew = spec->cap_mixer; knew->name; knew++) {
3298                         if (kname && strcmp(knew->name, kname) == 0)
3299                                 continue;
3300                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3301                         for (i = 0; kctl && i < kctl->count; i++) {
3302                                 err = snd_hda_add_nid(codec, kctl, i,
3303                                                       spec->adc_nids[i]);
3304                                 if (err < 0)
3305                                         return err;
3306                         }
3307                 }
3308         }
3309
3310         /* other nid->control mapping */
3311         for (i = 0; i < spec->num_mixers; i++) {
3312                 for (knew = spec->mixers[i]; knew->name; knew++) {
3313                         if (knew->iface != NID_MAPPING)
3314                                 continue;
3315                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3316                         if (kctl == NULL)
3317                                 continue;
3318                         u = knew->subdevice;
3319                         for (j = 0; j < 4; j++, u >>= 8) {
3320                                 nid = u & 0x3f;
3321                                 if (nid == 0)
3322                                         continue;
3323                                 switch (u & 0xc0) {
3324                                 case SUBDEV_SPEAKER_:
3325                                         nid = spec->autocfg.speaker_pins[nid];
3326                                         break;
3327                                 case SUBDEV_LINE_:
3328                                         nid = spec->autocfg.line_out_pins[nid];
3329                                         break;
3330                                 case SUBDEV_HP_:
3331                                         nid = spec->autocfg.hp_pins[nid];
3332                                         break;
3333                                 default:
3334                                         continue;
3335                                 }
3336                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3337                                 if (err < 0)
3338                                         return err;
3339                         }
3340                         u = knew->private_value;
3341                         for (j = 0; j < 4; j++, u >>= 8) {
3342                                 nid = u & 0xff;
3343                                 if (nid == 0)
3344                                         continue;
3345                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3346                                 if (err < 0)
3347                                         return err;
3348                         }
3349                 }
3350         }
3351
3352         alc_free_kctls(codec); /* no longer needed */
3353
3354         return 0;
3355 }
3356
3357
3358 /*
3359  * initialize the codec volumes, etc
3360  */
3361
3362 /*
3363  * generic initialization of ADC, input mixers and output mixers
3364  */
3365 static const struct hda_verb alc880_volume_init_verbs[] = {
3366         /*
3367          * Unmute ADC0-2 and set the default input to mic-in
3368          */
3369         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3370         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3371         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3372         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3373         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3374         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3375
3376         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3377          * mixer widget
3378          * Note: PASD motherboards uses the Line In 2 as the input for front
3379          * panel mic (mic 2)
3380          */
3381         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3382         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3383         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3384         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3385         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3386         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3387         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3388         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3389
3390         /*
3391          * Set up output mixers (0x0c - 0x0f)
3392          */
3393         /* set vol=0 to output mixers */
3394         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3395         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3396         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3397         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3398         /* set up input amps for analog loopback */
3399         /* Amp Indices: DAC = 0, mixer = 1 */
3400         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3401         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3402         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3403         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3404         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3405         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3406         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3407         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3408
3409         { }
3410 };
3411
3412 /*
3413  * 3-stack pin configuration:
3414  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3415  */
3416 static const struct hda_verb alc880_pin_3stack_init_verbs[] = {
3417         /*
3418          * preset connection lists of input pins
3419          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3420          */
3421         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3422         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3423         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3424
3425         /*
3426          * Set pin mode and muting
3427          */
3428         /* set front pin widgets 0x14 for output */
3429         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3430         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3431         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3432         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3433         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3434         /* Mic2 (as headphone out) for HP output */
3435         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3436         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3437         /* Line In pin widget for input */
3438         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3439         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3440         /* Line2 (as front mic) pin widget for input and vref at 80% */
3441         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3442         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3443         /* CD pin widget for input */
3444         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3445
3446         { }
3447 };
3448
3449 /*
3450  * 5-stack pin configuration:
3451  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3452  * line-in/side = 0x1a, f-mic = 0x1b
3453  */
3454 static const struct hda_verb alc880_pin_5stack_init_verbs[] = {
3455         /*
3456          * preset connection lists of input pins
3457          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3458          */
3459         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3460         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3461
3462         /*
3463          * Set pin mode and muting
3464          */
3465         /* set pin widgets 0x14-0x17 for output */
3466         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3467         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3468         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3469         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3470         /* unmute pins for output (no gain on this amp) */
3471         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3472         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3473         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3474         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3475
3476         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3477         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3478         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3479         /* Mic2 (as headphone out) for HP output */
3480         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3481         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3482         /* Line In pin widget for input */
3483         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3484         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3485         /* Line2 (as front mic) pin widget for input and vref at 80% */
3486         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3487         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3488         /* CD pin widget for input */
3489         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3490
3491         { }
3492 };
3493
3494 /*
3495  * W810 pin configuration:
3496  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3497  */
3498 static const struct hda_verb alc880_pin_w810_init_verbs[] = {
3499         /* hphone/speaker input selector: front DAC */
3500         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3501
3502         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3503         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3504         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3505         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3506         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3507         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3508
3509         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3510         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3511
3512         { }
3513 };
3514
3515 /*
3516  * Z71V pin configuration:
3517  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3518  */
3519 static const struct hda_verb alc880_pin_z71v_init_verbs[] = {
3520         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3521         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3522         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3523         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524
3525         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3526         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3527         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3528         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3529
3530         { }
3531 };
3532
3533 /*
3534  * 6-stack pin configuration:
3535  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3536  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3537  */
3538 static const struct hda_verb alc880_pin_6stack_init_verbs[] = {
3539         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3540
3541         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3542         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3543         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3544         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3545         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3546         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3547         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3548         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3549
3550         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3551         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3552         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3553         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3554         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3555         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3556         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3557         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3558         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3559
3560         { }
3561 };
3562
3563 /*
3564  * Uniwill pin configuration:
3565  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3566  * line = 0x1a
3567  */
3568 static const struct hda_verb alc880_uniwill_init_verbs[] = {
3569         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3570
3571         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3572         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3573         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3574         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3575         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3576         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3577         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3578         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3579         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3580         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3581         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3582         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3583         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3584         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3585
3586         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3587         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3588         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3589         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3590         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3591         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3592         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3593         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3594         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3595
3596         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3597         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3598
3599         { }
3600 };
3601
3602 /*
3603 * Uniwill P53
3604 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3605  */
3606 static const struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3607         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3608
3609         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3610         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3611         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3612         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3613         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3614         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3615         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3616         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3617         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3618         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3619         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3620         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3621
3622         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3623         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3624         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3625         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3626         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3627         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3628
3629         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3630         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3631
3632         { }
3633 };
3634
3635 static const struct hda_verb alc880_beep_init_verbs[] = {
3636         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3637         { }
3638 };
3639
3640 /* auto-toggle front mic */
3641 static void alc88x_simple_mic_automute(struct hda_codec *codec)
3642 {
3643         unsigned int present;
3644         unsigned char bits;
3645
3646         present = snd_hda_jack_detect(codec, 0x18);
3647         bits = present ? HDA_AMP_MUTE : 0;
3648         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3649 }
3650
3651 static void alc880_uniwill_setup(struct hda_codec *codec)
3652 {
3653         struct alc_spec *spec = codec->spec;
3654
3655         spec->autocfg.hp_pins[0] = 0x14;
3656         spec->autocfg.speaker_pins[0] = 0x15;
3657         spec->autocfg.speaker_pins[0] = 0x16;
3658         spec->automute = 1;
3659         spec->automute_mode = ALC_AUTOMUTE_AMP;
3660 }
3661
3662 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3663 {
3664         alc_hp_automute(codec);
3665         alc88x_simple_mic_automute(codec);
3666 }
3667
3668 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3669                                        unsigned int res)
3670 {
3671         /* Looks like the unsol event is incompatible with the standard
3672          * definition.  4bit tag is placed at 28 bit!
3673          */
3674         switch (res >> 28) {
3675         case ALC880_MIC_EVENT:
3676                 alc88x_simple_mic_automute(codec);
3677                 break;
3678         default:
3679                 alc_sku_unsol_event(codec, res);
3680                 break;
3681         }
3682 }
3683
3684 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3685 {
3686         struct alc_spec *spec = codec->spec;
3687
3688         spec->autocfg.hp_pins[0] = 0x14;
3689         spec->autocfg.speaker_pins[0] = 0x15;
3690         spec->automute = 1;
3691         spec->automute_mode = ALC_AUTOMUTE_AMP;
3692 }
3693
3694 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3695 {
3696         unsigned int present;
3697
3698         present = snd_hda_codec_read(codec, 0x21, 0,
3699                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3700         present &= HDA_AMP_VOLMASK;
3701         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3702                                  HDA_AMP_VOLMASK, present);
3703         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3704                                  HDA_AMP_VOLMASK, present);
3705 }
3706
3707 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3708                                            unsigned int res)
3709 {
3710         /* Looks like the unsol event is incompatible with the standard
3711          * definition.  4bit tag is placed at 28 bit!
3712          */
3713         if ((res >> 28) == ALC880_DCVOL_EVENT)
3714                 alc880_uniwill_p53_dcvol_automute(codec);
3715         else
3716                 alc_sku_unsol_event(codec, res);
3717 }
3718
3719 /*
3720  * F1734 pin configuration:
3721  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3722  */
3723 static const struct hda_verb alc880_pin_f1734_init_verbs[] = {
3724         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3725         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3726         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3727         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3728         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3729
3730         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3731         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3732         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3733         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3734
3735         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3736         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3737         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3738         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3739         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3740         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3741         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3742         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3743         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3744
3745         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3746         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3747
3748         { }
3749 };
3750
3751 /*
3752  * ASUS pin configuration:
3753  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3754  */
3755 static const struct hda_verb alc880_pin_asus_init_verbs[] = {
3756         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3757         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3758         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3759         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3760
3761         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3762         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3763         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3764         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3765         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3766         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3767         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3768         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3769
3770         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3771         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3772         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3773         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3774         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3775         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3776         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3777         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3778         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3779
3780         { }
3781 };
3782
3783 /* Enable GPIO mask and set output */
3784 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3785 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3786 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3787
3788 /* Clevo m520g init */
3789 static const struct hda_verb alc880_pin_clevo_init_verbs[] = {
3790         /* headphone output */
3791         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3792         /* line-out */
3793         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3794         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3795         /* Line-in */
3796         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3797         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3798         /* CD */
3799         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3800         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3801         /* Mic1 (rear panel) */
3802         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3803         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3804         /* Mic2 (front panel) */
3805         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3806         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3807         /* headphone */
3808         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3809         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3810         /* change to EAPD mode */
3811         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3812         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3813
3814         { }
3815 };
3816
3817 static const struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3818         /* change to EAPD mode */
3819         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3820         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3821
3822         /* Headphone output */
3823         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3824         /* Front output*/
3825         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3826         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3827
3828         /* Line In pin widget for input */
3829         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3830         /* CD pin widget for input */
3831         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3832         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3833         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3834
3835         /* change to EAPD mode */
3836         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3837         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3838
3839         { }
3840 };
3841
3842 /*
3843  * LG m1 express dual
3844  *
3845  * Pin assignment:
3846  *   Rear Line-In/Out (blue): 0x14
3847  *   Build-in Mic-In: 0x15
3848  *   Speaker-out: 0x17
3849  *   HP-Out (green): 0x1b
3850  *   Mic-In/Out (red): 0x19
3851  *   SPDIF-Out: 0x1e
3852  */
3853
3854 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3855 static const hda_nid_t alc880_lg_dac_nids[3] = {
3856         0x05, 0x02, 0x03
3857 };
3858
3859 /* seems analog CD is not working */
3860 static const struct hda_input_mux alc880_lg_capture_source = {
3861         .num_items = 3,
3862         .items = {
3863                 { "Mic", 0x1 },
3864                 { "Line", 0x5 },
3865                 { "Internal Mic", 0x6 },
3866         },
3867 };
3868
3869 /* 2,4,6 channel modes */
3870 static const struct hda_verb alc880_lg_ch2_init[] = {
3871         /* set line-in and mic-in to input */
3872         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3873         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3874         { }
3875 };
3876
3877 static const struct hda_verb alc880_lg_ch4_init[] = {
3878         /* set line-in to out and mic-in to input */
3879         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3880         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3881         { }
3882 };
3883
3884 static const struct hda_verb alc880_lg_ch6_init[] = {
3885         /* set line-in and mic-in to output */
3886         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3887         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3888         { }
3889 };
3890
3891 static const struct hda_channel_mode alc880_lg_ch_modes[3] = {
3892         { 2, alc880_lg_ch2_init },
3893         { 4, alc880_lg_ch4_init },
3894         { 6, alc880_lg_ch6_init },
3895 };
3896
3897 static const struct snd_kcontrol_new alc880_lg_mixer[] = {
3898         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3899         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3900         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3901         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3902         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3903         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3904         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3905         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3906         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3907         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3908         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3909         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3910         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3911         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3912         {
3913                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3914                 .name = "Channel Mode",
3915                 .info = alc_ch_mode_info,
3916                 .get = alc_ch_mode_get,
3917                 .put = alc_ch_mode_put,
3918         },
3919         { } /* end */
3920 };
3921
3922 static const struct hda_verb alc880_lg_init_verbs[] = {
3923         /* set capture source to mic-in */
3924         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3925         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3926         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3927         /* mute all amp mixer inputs */
3928         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3929         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3930         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3931         /* line-in to input */
3932         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3933         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3934         /* built-in mic */
3935         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3936         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3937         /* speaker-out */
3938         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3939         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3940         /* mic-in to input */
3941         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3942         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3943         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3944         /* HP-out */
3945         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3946         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3947         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3948         /* jack sense */
3949         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3950         { }
3951 };
3952
3953 /* toggle speaker-output according to the hp-jack state */
3954 static void alc880_lg_setup(struct hda_codec *codec)
3955 {
3956         struct alc_spec *spec = codec->spec;
3957
3958         spec->autocfg.hp_pins[0] = 0x1b;
3959         spec->autocfg.speaker_pins[0] = 0x17;
3960         spec->automute = 1;
3961         spec->automute_mode = ALC_AUTOMUTE_AMP;
3962 }
3963
3964 /*
3965  * LG LW20
3966  *
3967  * Pin assignment:
3968  *   Speaker-out: 0x14
3969  *   Mic-In: 0x18
3970  *   Built-in Mic-In: 0x19
3971  *   Line-In: 0x1b
3972  *   HP-Out: 0x1a
3973  *   SPDIF-Out: 0x1e
3974  */
3975
3976 static const struct hda_input_mux alc880_lg_lw_capture_source = {
3977         .num_items = 3,
3978         .items = {
3979                 { "Mic", 0x0 },
3980                 { "Internal Mic", 0x1 },
3981                 { "Line In", 0x2 },
3982         },
3983 };
3984
3985 #define alc880_lg_lw_modes alc880_threestack_modes
3986
3987 static const struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3988         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3989         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3990         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3991         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3992         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3993         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3994         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3995         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3996         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3997         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3998         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3999         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4000         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
4001         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
4002         {
4003                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4004                 .name = "Channel Mode",
4005                 .info = alc_ch_mode_info,
4006                 .get = alc_ch_mode_get,
4007                 .put = alc_ch_mode_put,
4008         },
4009         { } /* end */
4010 };
4011
4012 static const struct hda_verb alc880_lg_lw_init_verbs[] = {
4013         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
4014         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
4015         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
4016
4017         /* set capture source to mic-in */
4018         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4019         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4020         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4021         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4022         /* speaker-out */
4023         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4024         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4025         /* HP-out */
4026         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4027         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4028         /* mic-in to input */
4029         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4030         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4031         /* built-in mic */
4032         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4033         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4034         /* jack sense */
4035         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4036         { }
4037 };
4038
4039 /* toggle speaker-output according to the hp-jack state */
4040 static void alc880_lg_lw_setup(struct hda_codec *codec)
4041 {
4042         struct alc_spec *spec = codec->spec;
4043
4044         spec->autocfg.hp_pins[0] = 0x1b;
4045         spec->autocfg.speaker_pins[0] = 0x14;
4046         spec->automute = 1;
4047         spec->automute_mode = ALC_AUTOMUTE_AMP;
4048 }
4049
4050 static const struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
4051         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4052         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
4053         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4054         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4055         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
4056         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
4057         { } /* end */
4058 };
4059
4060 static const struct hda_input_mux alc880_medion_rim_capture_source = {
4061         .num_items = 2,
4062         .items = {
4063                 { "Mic", 0x0 },
4064                 { "Internal Mic", 0x1 },
4065         },
4066 };
4067
4068 static const struct hda_verb alc880_medion_rim_init_verbs[] = {
4069         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
4070
4071         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4072         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4073
4074         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4075         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4076         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4077         /* Mic2 (as headphone out) for HP output */
4078         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4079         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4080         /* Internal Speaker */
4081         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4082         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4083
4084         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
4085         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
4086
4087         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4088         { }
4089 };
4090
4091 /* toggle speaker-output according to the hp-jack state */
4092 static void alc880_medion_rim_automute(struct hda_codec *codec)
4093 {
4094         struct alc_spec *spec = codec->spec;
4095         alc_hp_automute(codec);
4096         /* toggle EAPD */
4097         if (spec->jack_present)
4098                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
4099         else
4100                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
4101 }
4102
4103 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
4104                                           unsigned int res)
4105 {
4106         /* Looks like the unsol event is incompatible with the standard
4107          * definition.  4bit tag is placed at 28 bit!
4108          */
4109         if ((res >> 28) == ALC880_HP_EVENT)
4110                 alc880_medion_rim_automute(codec);
4111 }
4112
4113 static void alc880_medion_rim_setup(struct hda_codec *codec)
4114 {
4115         struct alc_spec *spec = codec->spec;
4116
4117         spec->autocfg.hp_pins[0] = 0x14;
4118         spec->autocfg.speaker_pins[0] = 0x1b;
4119         spec->automute = 1;
4120         spec->automute_mode = ALC_AUTOMUTE_AMP;
4121 }
4122
4123 #ifdef CONFIG_SND_HDA_POWER_SAVE
4124 static const struct hda_amp_list alc880_loopbacks[] = {
4125         { 0x0b, HDA_INPUT, 0 },
4126         { 0x0b, HDA_INPUT, 1 },
4127         { 0x0b, HDA_INPUT, 2 },
4128         { 0x0b, HDA_INPUT, 3 },
4129         { 0x0b, HDA_INPUT, 4 },
4130         { } /* end */
4131 };
4132
4133 static const struct hda_amp_list alc880_lg_loopbacks[] = {
4134         { 0x0b, HDA_INPUT, 1 },
4135         { 0x0b, HDA_INPUT, 6 },
4136         { 0x0b, HDA_INPUT, 7 },
4137         { } /* end */
4138 };
4139 #endif
4140
4141 /*
4142  * Common callbacks
4143  */
4144
4145 static void alc_init_special_input_src(struct hda_codec *codec);
4146
4147 static int alc_init(struct hda_codec *codec)
4148 {
4149         struct alc_spec *spec = codec->spec;
4150         unsigned int i;
4151
4152         alc_fix_pll(codec);
4153         alc_auto_init_amp(codec, spec->init_amp);
4154
4155         for (i = 0; i < spec->num_init_verbs; i++)
4156                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
4157         alc_init_special_input_src(codec);
4158
4159         if (spec->init_hook)
4160                 spec->init_hook(codec);
4161
4162         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
4163
4164         hda_call_check_power_status(codec, 0x01);
4165         return 0;
4166 }
4167
4168 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
4169 {
4170         struct alc_spec *spec = codec->spec;
4171
4172         if (spec->unsol_event)
4173                 spec->unsol_event(codec, res);
4174 }
4175
4176 #ifdef CONFIG_SND_HDA_POWER_SAVE
4177 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4178 {
4179         struct alc_spec *spec = codec->spec;
4180         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4181 }
4182 #endif
4183
4184 /*
4185  * Analog playback callbacks
4186  */
4187 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
4188                                     struct hda_codec *codec,
4189                                     struct snd_pcm_substream *substream)
4190 {
4191         struct alc_spec *spec = codec->spec;
4192         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
4193                                              hinfo);
4194 }
4195
4196 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4197                                        struct hda_codec *codec,
4198                                        unsigned int stream_tag,
4199                                        unsigned int format,
4200                                        struct snd_pcm_substream *substream)
4201 {
4202         struct alc_spec *spec = codec->spec;
4203         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4204                                                 stream_tag, format, substream);
4205 }
4206
4207 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4208                                        struct hda_codec *codec,
4209                                        struct snd_pcm_substream *substream)
4210 {
4211         struct alc_spec *spec = codec->spec;
4212         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4213 }
4214
4215 /*
4216  * Digital out
4217  */
4218 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4219                                         struct hda_codec *codec,
4220                                         struct snd_pcm_substream *substream)
4221 {
4222         struct alc_spec *spec = codec->spec;
4223         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4224 }
4225
4226 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4227                                            struct hda_codec *codec,
4228                                            unsigned int stream_tag,
4229                                            unsigned int format,
4230                                            struct snd_pcm_substream *substream)
4231 {
4232         struct alc_spec *spec = codec->spec;
4233         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4234                                              stream_tag, format, substream);
4235 }
4236
4237 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4238                                            struct hda_codec *codec,
4239                                            struct snd_pcm_substream *substream)
4240 {
4241         struct alc_spec *spec = codec->spec;
4242         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4243 }
4244
4245 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4246                                          struct hda_codec *codec,
4247                                          struct snd_pcm_substream *substream)
4248 {
4249         struct alc_spec *spec = codec->spec;
4250         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4251 }
4252
4253 /*
4254  * Analog capture
4255  */
4256 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4257                                       struct hda_codec *codec,
4258                                       unsigned int stream_tag,
4259                                       unsigned int format,
4260                                       struct snd_pcm_substream *substream)
4261 {
4262         struct alc_spec *spec = codec->spec;
4263
4264         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4265                                    stream_tag, 0, format);
4266         return 0;
4267 }
4268
4269 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4270                                       struct hda_codec *codec,
4271                                       struct snd_pcm_substream *substream)
4272 {
4273         struct alc_spec *spec = codec->spec;
4274
4275         snd_hda_codec_cleanup_stream(codec,
4276                                      spec->adc_nids[substream->number + 1]);
4277         return 0;
4278 }
4279
4280 /* analog capture with dynamic dual-adc changes */
4281 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4282                                        struct hda_codec *codec,
4283                                        unsigned int stream_tag,
4284                                        unsigned int format,
4285                                        struct snd_pcm_substream *substream)
4286 {
4287         struct alc_spec *spec = codec->spec;
4288         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
4289         spec->cur_adc_stream_tag = stream_tag;
4290         spec->cur_adc_format = format;
4291         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4292         return 0;
4293 }
4294
4295 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4296                                        struct hda_codec *codec,
4297                                        struct snd_pcm_substream *substream)
4298 {
4299         struct alc_spec *spec = codec->spec;
4300         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4301         spec->cur_adc = 0;
4302         return 0;
4303 }
4304
4305 static const struct hda_pcm_stream dualmic_pcm_analog_capture = {
4306         .substreams = 1,
4307         .channels_min = 2,
4308         .channels_max = 2,
4309         .nid = 0, /* fill later */
4310         .ops = {
4311                 .prepare = dualmic_capture_pcm_prepare,
4312                 .cleanup = dualmic_capture_pcm_cleanup
4313         },
4314 };
4315
4316 /*
4317  */
4318 static const struct hda_pcm_stream alc880_pcm_analog_playback = {
4319         .substreams = 1,
4320         .channels_min = 2,
4321         .channels_max = 8,
4322         /* NID is set in alc_build_pcms */
4323         .ops = {
4324                 .open = alc880_playback_pcm_open,
4325                 .prepare = alc880_playback_pcm_prepare,
4326                 .cleanup = alc880_playback_pcm_cleanup
4327         },
4328 };
4329
4330 static const struct hda_pcm_stream alc880_pcm_analog_capture = {
4331         .substreams = 1,
4332         .channels_min = 2,
4333         .channels_max = 2,
4334         /* NID is set in alc_build_pcms */
4335 };
4336
4337 static const struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4338         .substreams = 1,
4339         .channels_min = 2,
4340         .channels_max = 2,
4341         /* NID is set in alc_build_pcms */
4342 };
4343
4344 static const struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4345         .substreams = 2, /* can be overridden */
4346         .channels_min = 2,
4347         .channels_max = 2,
4348         /* NID is set in alc_build_pcms */
4349         .ops = {
4350                 .prepare = alc880_alt_capture_pcm_prepare,
4351                 .cleanup = alc880_alt_capture_pcm_cleanup
4352         },
4353 };
4354
4355 static const struct hda_pcm_stream alc880_pcm_digital_playback = {
4356         .substreams = 1,
4357         .channels_min = 2,
4358         .channels_max = 2,
4359         /* NID is set in alc_build_pcms */
4360         .ops = {
4361                 .open = alc880_dig_playback_pcm_open,
4362                 .close = alc880_dig_playback_pcm_close,
4363                 .prepare = alc880_dig_playback_pcm_prepare,
4364                 .cleanup = alc880_dig_playback_pcm_cleanup
4365         },
4366 };
4367
4368 static const struct hda_pcm_stream alc880_pcm_digital_capture = {
4369         .substreams = 1,
4370         .channels_min = 2,
4371         .channels_max = 2,
4372         /* NID is set in alc_build_pcms */
4373 };
4374
4375 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4376 static const struct hda_pcm_stream alc_pcm_null_stream = {
4377         .substreams = 0,
4378         .channels_min = 0,
4379         .channels_max = 0,
4380 };
4381
4382 static int alc_build_pcms(struct hda_codec *codec)
4383 {
4384         struct alc_spec *spec = codec->spec;
4385         struct hda_pcm *info = spec->pcm_rec;
4386         int i;
4387
4388         codec->num_pcms = 1;
4389         codec->pcm_info = info;
4390
4391         if (spec->no_analog)
4392                 goto skip_analog;
4393
4394         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4395                  "%s Analog", codec->chip_name);
4396         info->name = spec->stream_name_analog;
4397
4398         if (spec->stream_analog_playback) {
4399                 if (snd_BUG_ON(!spec->multiout.dac_nids))
4400                         return -EINVAL;
4401                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4402                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4403         }
4404         if (spec->stream_analog_capture) {
4405                 if (snd_BUG_ON(!spec->adc_nids))
4406                         return -EINVAL;
4407                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4408                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4409         }
4410
4411         if (spec->channel_mode) {
4412                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4413                 for (i = 0; i < spec->num_channel_mode; i++) {
4414                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4415                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4416                         }
4417                 }
4418         }
4419
4420  skip_analog:
4421         /* SPDIF for stream index #1 */
4422         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4423                 snprintf(spec->stream_name_digital,
4424                          sizeof(spec->stream_name_digital),
4425                          "%s Digital", codec->chip_name);
4426                 codec->num_pcms = 2;
4427                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4428                 info = spec->pcm_rec + 1;
4429                 info->name = spec->stream_name_digital;
4430                 if (spec->dig_out_type)
4431                         info->pcm_type = spec->dig_out_type;
4432                 else
4433                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4434                 if (spec->multiout.dig_out_nid &&
4435                     spec->stream_digital_playback) {
4436                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4437                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4438                 }
4439                 if (spec->dig_in_nid &&
4440                     spec->stream_digital_capture) {
4441                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4442                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4443                 }
4444                 /* FIXME: do we need this for all Realtek codec models? */
4445                 codec->spdif_status_reset = 1;
4446         }
4447
4448         if (spec->no_analog)
4449                 return 0;
4450
4451         /* If the use of more than one ADC is requested for the current
4452          * model, configure a second analog capture-only PCM.
4453          */
4454         /* Additional Analaog capture for index #2 */
4455         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4456             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4457                 codec->num_pcms = 3;
4458                 info = spec->pcm_rec + 2;
4459                 info->name = spec->stream_name_analog;
4460                 if (spec->alt_dac_nid) {
4461                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4462                                 *spec->stream_analog_alt_playback;
4463                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4464                                 spec->alt_dac_nid;
4465                 } else {
4466                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4467                                 alc_pcm_null_stream;
4468                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4469                 }
4470                 if (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture) {
4471                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4472                                 *spec->stream_analog_alt_capture;
4473                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4474                                 spec->adc_nids[1];
4475                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4476                                 spec->num_adc_nids - 1;
4477                 } else {
4478                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4479                                 alc_pcm_null_stream;
4480                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4481                 }
4482         }
4483
4484         return 0;
4485 }
4486
4487 static inline void alc_shutup(struct hda_codec *codec)
4488 {
4489         struct alc_spec *spec = codec->spec;
4490
4491         if (spec && spec->shutup)
4492                 spec->shutup(codec);
4493         snd_hda_shutup_pins(codec);
4494 }
4495
4496 static void alc_free_kctls(struct hda_codec *codec)
4497 {
4498         struct alc_spec *spec = codec->spec;
4499
4500         if (spec->kctls.list) {
4501                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4502                 int i;
4503                 for (i = 0; i < spec->kctls.used; i++)
4504                         kfree(kctl[i].name);
4505         }
4506         snd_array_free(&spec->kctls);
4507 }
4508
4509 static void alc_free(struct hda_codec *codec)
4510 {
4511         struct alc_spec *spec = codec->spec;
4512
4513         if (!spec)
4514                 return;
4515
4516         alc_shutup(codec);
4517         snd_hda_input_jack_free(codec);
4518         alc_free_kctls(codec);
4519         kfree(spec);
4520         snd_hda_detach_beep_device(codec);
4521 }
4522
4523 #ifdef CONFIG_SND_HDA_POWER_SAVE
4524 static void alc_power_eapd(struct hda_codec *codec)
4525 {
4526         alc_auto_setup_eapd(codec, false);
4527 }
4528
4529 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4530 {
4531         struct alc_spec *spec = codec->spec;
4532         alc_shutup(codec);
4533         if (spec && spec->power_hook)
4534                 spec->power_hook(codec);
4535         return 0;
4536 }
4537 #endif
4538
4539 #ifdef SND_HDA_NEEDS_RESUME
4540 static int alc_resume(struct hda_codec *codec)
4541 {
4542         msleep(150); /* to avoid pop noise */
4543         codec->patch_ops.init(codec);
4544         snd_hda_codec_resume_amp(codec);
4545         snd_hda_codec_resume_cache(codec);
4546         hda_call_check_power_status(codec, 0x01);
4547         return 0;
4548 }
4549 #endif
4550
4551 /*
4552  */
4553 static const struct hda_codec_ops alc_patch_ops = {
4554         .build_controls = alc_build_controls,
4555         .build_pcms = alc_build_pcms,
4556         .init = alc_init,
4557         .free = alc_free,
4558         .unsol_event = alc_unsol_event,
4559 #ifdef SND_HDA_NEEDS_RESUME
4560         .resume = alc_resume,
4561 #endif
4562 #ifdef CONFIG_SND_HDA_POWER_SAVE
4563         .suspend = alc_suspend,
4564         .check_power_status = alc_check_power_status,
4565 #endif
4566         .reboot_notify = alc_shutup,
4567 };
4568
4569 /* replace the codec chip_name with the given string */
4570 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4571 {
4572         kfree(codec->chip_name);
4573         codec->chip_name = kstrdup(name, GFP_KERNEL);
4574         if (!codec->chip_name) {
4575                 alc_free(codec);
4576                 return -ENOMEM;
4577         }
4578         return 0;
4579 }
4580
4581 /*
4582  * Test configuration for debugging
4583  *
4584  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4585  * enum controls.
4586  */
4587 #ifdef CONFIG_SND_DEBUG
4588 static const hda_nid_t alc880_test_dac_nids[4] = {
4589         0x02, 0x03, 0x04, 0x05
4590 };
4591
4592 static const struct hda_input_mux alc880_test_capture_source = {
4593         .num_items = 7,
4594         .items = {
4595                 { "In-1", 0x0 },
4596                 { "In-2", 0x1 },
4597                 { "In-3", 0x2 },
4598                 { "In-4", 0x3 },
4599                 { "CD", 0x4 },
4600                 { "Front", 0x5 },
4601                 { "Surround", 0x6 },
4602         },
4603 };
4604
4605 static const struct hda_channel_mode alc880_test_modes[4] = {
4606         { 2, NULL },
4607         { 4, NULL },
4608         { 6, NULL },
4609         { 8, NULL },
4610 };
4611
4612 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4613                                  struct snd_ctl_elem_info *uinfo)
4614 {
4615         static const char * const texts[] = {
4616                 "N/A", "Line Out", "HP Out",
4617                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4618         };
4619         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4620         uinfo->count = 1;
4621         uinfo->value.enumerated.items = 8;
4622         if (uinfo->value.enumerated.item >= 8)
4623                 uinfo->value.enumerated.item = 7;
4624         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4625         return 0;
4626 }
4627
4628 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4629                                 struct snd_ctl_elem_value *ucontrol)
4630 {
4631         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4632         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4633         unsigned int pin_ctl, item = 0;
4634
4635         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4636                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4637         if (pin_ctl & AC_PINCTL_OUT_EN) {
4638                 if (pin_ctl & AC_PINCTL_HP_EN)
4639                         item = 2;
4640                 else
4641                         item = 1;
4642         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4643                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4644                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4645                 case AC_PINCTL_VREF_50:  item = 4; break;
4646                 case AC_PINCTL_VREF_GRD: item = 5; break;
4647                 case AC_PINCTL_VREF_80:  item = 6; break;
4648                 case AC_PINCTL_VREF_100: item = 7; break;
4649                 }
4650         }
4651         ucontrol->value.enumerated.item[0] = item;
4652         return 0;
4653 }
4654
4655 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4656                                 struct snd_ctl_elem_value *ucontrol)
4657 {
4658         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4659         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4660         static const unsigned int ctls[] = {
4661                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4662                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4663                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4664                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4665                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4666                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4667         };
4668         unsigned int old_ctl, new_ctl;
4669
4670         old_ctl = snd_hda_codec_read(codec, nid, 0,
4671                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4672         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4673         if (old_ctl != new_ctl) {
4674                 int val;
4675                 snd_hda_codec_write_cache(codec, nid, 0,
4676                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4677                                           new_ctl);
4678                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4679                         HDA_AMP_MUTE : 0;
4680                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4681                                          HDA_AMP_MUTE, val);
4682                 return 1;
4683         }
4684         return 0;
4685 }
4686
4687 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4688                                  struct snd_ctl_elem_info *uinfo)
4689 {
4690         static const char * const texts[] = {
4691                 "Front", "Surround", "CLFE", "Side"
4692         };
4693         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4694         uinfo->count = 1;
4695         uinfo->value.enumerated.items = 4;
4696         if (uinfo->value.enumerated.item >= 4)
4697                 uinfo->value.enumerated.item = 3;
4698         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4699         return 0;
4700 }
4701
4702 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4703                                 struct snd_ctl_elem_value *ucontrol)
4704 {
4705         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4706         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4707         unsigned int sel;
4708
4709         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4710         ucontrol->value.enumerated.item[0] = sel & 3;
4711         return 0;
4712 }
4713
4714 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4715                                 struct snd_ctl_elem_value *ucontrol)
4716 {
4717         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4718         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4719         unsigned int sel;
4720
4721         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4722         if (ucontrol->value.enumerated.item[0] != sel) {
4723                 sel = ucontrol->value.enumerated.item[0] & 3;
4724                 snd_hda_codec_write_cache(codec, nid, 0,
4725                                           AC_VERB_SET_CONNECT_SEL, sel);
4726                 return 1;
4727         }
4728         return 0;
4729 }
4730
4731 #define PIN_CTL_TEST(xname,nid) {                       \
4732                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4733                         .name = xname,                 \
4734                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4735                         .info = alc_test_pin_ctl_info, \
4736                         .get = alc_test_pin_ctl_get,   \
4737                         .put = alc_test_pin_ctl_put,   \
4738                         .private_value = nid           \
4739                         }
4740
4741 #define PIN_SRC_TEST(xname,nid) {                       \
4742                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4743                         .name = xname,                 \
4744                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4745                         .info = alc_test_pin_src_info, \
4746                         .get = alc_test_pin_src_get,   \
4747                         .put = alc_test_pin_src_put,   \
4748                         .private_value = nid           \
4749                         }
4750
4751 static const struct snd_kcontrol_new alc880_test_mixer[] = {
4752         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4753         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4754         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4755         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4756         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4757         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4758         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4759         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4760         PIN_CTL_TEST("Front Pin Mode", 0x14),
4761         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4762         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4763         PIN_CTL_TEST("Side Pin Mode", 0x17),
4764         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4765         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4766         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4767         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4768         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4769         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4770         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4771         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4772         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4773         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4774         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4775         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4776         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4777         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4778         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4779         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4780         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4781         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4782         {
4783                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4784                 .name = "Channel Mode",
4785                 .info = alc_ch_mode_info,
4786                 .get = alc_ch_mode_get,
4787                 .put = alc_ch_mode_put,
4788         },
4789         { } /* end */
4790 };
4791
4792 static const struct hda_verb alc880_test_init_verbs[] = {
4793         /* Unmute inputs of 0x0c - 0x0f */
4794         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4795         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4796         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4797         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4798         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4799         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4800         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4801         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4802         /* Vol output for 0x0c-0x0f */
4803         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4804         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4805         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4806         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4807         /* Set output pins 0x14-0x17 */
4808         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4809         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4810         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4811         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4812         /* Unmute output pins 0x14-0x17 */
4813         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4814         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4815         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4816         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4817         /* Set input pins 0x18-0x1c */
4818         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4819         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4820         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4821         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4822         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4823         /* Mute input pins 0x18-0x1b */
4824         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4825         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4826         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4827         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4828         /* ADC set up */
4829         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4830         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4831         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4832         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4833         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4834         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4835         /* Analog input/passthru */
4836         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4837         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4838         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4839         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4840         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4841         { }
4842 };
4843 #endif
4844
4845 /*
4846  */
4847
4848 static const char * const alc880_models[ALC880_MODEL_LAST] = {
4849         [ALC880_3ST]            = "3stack",
4850         [ALC880_TCL_S700]       = "tcl",
4851         [ALC880_3ST_DIG]        = "3stack-digout",
4852         [ALC880_CLEVO]          = "clevo",
4853         [ALC880_5ST]            = "5stack",
4854         [ALC880_5ST_DIG]        = "5stack-digout",
4855         [ALC880_W810]           = "w810",
4856         [ALC880_Z71V]           = "z71v",
4857         [ALC880_6ST]            = "6stack",
4858         [ALC880_6ST_DIG]        = "6stack-digout",
4859         [ALC880_ASUS]           = "asus",
4860         [ALC880_ASUS_W1V]       = "asus-w1v",
4861         [ALC880_ASUS_DIG]       = "asus-dig",
4862         [ALC880_ASUS_DIG2]      = "asus-dig2",
4863         [ALC880_UNIWILL_DIG]    = "uniwill",
4864         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4865         [ALC880_FUJITSU]        = "fujitsu",
4866         [ALC880_F1734]          = "F1734",
4867         [ALC880_LG]             = "lg",
4868         [ALC880_LG_LW]          = "lg-lw",
4869         [ALC880_MEDION_RIM]     = "medion",
4870 #ifdef CONFIG_SND_DEBUG
4871         [ALC880_TEST]           = "test",
4872 #endif
4873         [ALC880_AUTO]           = "auto",
4874 };
4875
4876 static const struct snd_pci_quirk alc880_cfg_tbl[] = {
4877         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4878         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4879         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4880         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4881         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4882         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4883         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4884         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4885         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4886         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4887         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4888         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4889         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4890         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4891         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4892         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4893         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4894         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4895         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4896         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4897         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4898         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4899         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4900         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4901         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4902         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4903         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4904         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4905         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4906         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4907         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4908         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4909         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4910         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4911         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4912         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4913         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4914         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4915         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4916         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_F1734),
4917         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4918         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4919         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4920         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4921         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4922         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4923         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4924         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4925         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4926         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4927         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4928         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4929         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4930         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4931         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4932         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4933         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4934         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4935         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4936         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4937         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4938         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4939         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4940         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4941         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4942         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4943         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4944         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4945         /* default Intel */
4946         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4947         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4948         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4949         {}
4950 };
4951
4952 /*
4953  * ALC880 codec presets
4954  */
4955 static const struct alc_config_preset alc880_presets[] = {
4956         [ALC880_3ST] = {
4957                 .mixers = { alc880_three_stack_mixer },
4958                 .init_verbs = { alc880_volume_init_verbs,
4959                                 alc880_pin_3stack_init_verbs },
4960                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4961                 .dac_nids = alc880_dac_nids,
4962                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4963                 .channel_mode = alc880_threestack_modes,
4964                 .need_dac_fix = 1,
4965                 .input_mux = &alc880_capture_source,
4966         },
4967         [ALC880_3ST_DIG] = {
4968                 .mixers = { alc880_three_stack_mixer },
4969                 .init_verbs = { alc880_volume_init_verbs,
4970                                 alc880_pin_3stack_init_verbs },
4971                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4972                 .dac_nids = alc880_dac_nids,
4973                 .dig_out_nid = ALC880_DIGOUT_NID,
4974                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4975                 .channel_mode = alc880_threestack_modes,
4976                 .need_dac_fix = 1,
4977                 .input_mux = &alc880_capture_source,
4978         },
4979         [ALC880_TCL_S700] = {
4980                 .mixers = { alc880_tcl_s700_mixer },
4981                 .init_verbs = { alc880_volume_init_verbs,
4982                                 alc880_pin_tcl_S700_init_verbs,
4983                                 alc880_gpio2_init_verbs },
4984                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4985                 .dac_nids = alc880_dac_nids,
4986                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4987                 .num_adc_nids = 1, /* single ADC */
4988                 .hp_nid = 0x03,
4989                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4990                 .channel_mode = alc880_2_jack_modes,
4991                 .input_mux = &alc880_capture_source,
4992         },
4993         [ALC880_5ST] = {
4994                 .mixers = { alc880_three_stack_mixer,
4995                             alc880_five_stack_mixer},
4996                 .init_verbs = { alc880_volume_init_verbs,
4997                                 alc880_pin_5stack_init_verbs },
4998                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4999                 .dac_nids = alc880_dac_nids,
5000                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
5001                 .channel_mode = alc880_fivestack_modes,
5002                 .input_mux = &alc880_capture_source,
5003         },
5004         [ALC880_5ST_DIG] = {
5005                 .mixers = { alc880_three_stack_mixer,
5006                             alc880_five_stack_mixer },
5007                 .init_verbs = { alc880_volume_init_verbs,
5008                                 alc880_pin_5stack_init_verbs },
5009                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5010                 .dac_nids = alc880_dac_nids,
5011                 .dig_out_nid = ALC880_DIGOUT_NID,
5012                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
5013                 .channel_mode = alc880_fivestack_modes,
5014                 .input_mux = &alc880_capture_source,
5015         },
5016         [ALC880_6ST] = {
5017                 .mixers = { alc880_six_stack_mixer },
5018                 .init_verbs = { alc880_volume_init_verbs,
5019                                 alc880_pin_6stack_init_verbs },
5020                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
5021                 .dac_nids = alc880_6st_dac_nids,
5022                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
5023                 .channel_mode = alc880_sixstack_modes,
5024                 .input_mux = &alc880_6stack_capture_source,
5025         },
5026         [ALC880_6ST_DIG] = {
5027                 .mixers = { alc880_six_stack_mixer },
5028                 .init_verbs = { alc880_volume_init_verbs,
5029                                 alc880_pin_6stack_init_verbs },
5030                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
5031                 .dac_nids = alc880_6st_dac_nids,
5032                 .dig_out_nid = ALC880_DIGOUT_NID,
5033                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
5034                 .channel_mode = alc880_sixstack_modes,
5035                 .input_mux = &alc880_6stack_capture_source,
5036         },
5037         [ALC880_W810] = {
5038                 .mixers = { alc880_w810_base_mixer },
5039                 .init_verbs = { alc880_volume_init_verbs,
5040                                 alc880_pin_w810_init_verbs,
5041                                 alc880_gpio2_init_verbs },
5042                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
5043                 .dac_nids = alc880_w810_dac_nids,
5044                 .dig_out_nid = ALC880_DIGOUT_NID,
5045                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
5046                 .channel_mode = alc880_w810_modes,
5047                 .input_mux = &alc880_capture_source,
5048         },
5049         [ALC880_Z71V] = {
5050                 .mixers = { alc880_z71v_mixer },
5051                 .init_verbs = { alc880_volume_init_verbs,
5052                                 alc880_pin_z71v_init_verbs },
5053                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
5054                 .dac_nids = alc880_z71v_dac_nids,
5055                 .dig_out_nid = ALC880_DIGOUT_NID,
5056                 .hp_nid = 0x03,
5057                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5058                 .channel_mode = alc880_2_jack_modes,
5059                 .input_mux = &alc880_capture_source,
5060         },
5061         [ALC880_F1734] = {
5062                 .mixers = { alc880_f1734_mixer },
5063                 .init_verbs = { alc880_volume_init_verbs,
5064                                 alc880_pin_f1734_init_verbs },
5065                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
5066                 .dac_nids = alc880_f1734_dac_nids,
5067                 .hp_nid = 0x02,
5068                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5069                 .channel_mode = alc880_2_jack_modes,
5070                 .input_mux = &alc880_f1734_capture_source,
5071                 .unsol_event = alc880_uniwill_p53_unsol_event,
5072                 .setup = alc880_uniwill_p53_setup,
5073                 .init_hook = alc_hp_automute,
5074         },
5075         [ALC880_ASUS] = {
5076                 .mixers = { alc880_asus_mixer },
5077                 .init_verbs = { alc880_volume_init_verbs,
5078                                 alc880_pin_asus_init_verbs,
5079                                 alc880_gpio1_init_verbs },
5080                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5081                 .dac_nids = alc880_asus_dac_nids,
5082                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5083                 .channel_mode = alc880_asus_modes,
5084                 .need_dac_fix = 1,
5085                 .input_mux = &alc880_capture_source,
5086         },
5087         [ALC880_ASUS_DIG] = {
5088                 .mixers = { alc880_asus_mixer },
5089                 .init_verbs = { alc880_volume_init_verbs,
5090                                 alc880_pin_asus_init_verbs,
5091                                 alc880_gpio1_init_verbs },
5092                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5093                 .dac_nids = alc880_asus_dac_nids,
5094                 .dig_out_nid = ALC880_DIGOUT_NID,
5095                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5096                 .channel_mode = alc880_asus_modes,
5097                 .need_dac_fix = 1,
5098                 .input_mux = &alc880_capture_source,
5099         },
5100         [ALC880_ASUS_DIG2] = {
5101                 .mixers = { alc880_asus_mixer },
5102                 .init_verbs = { alc880_volume_init_verbs,
5103                                 alc880_pin_asus_init_verbs,
5104                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
5105                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5106                 .dac_nids = alc880_asus_dac_nids,
5107                 .dig_out_nid = ALC880_DIGOUT_NID,
5108                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5109                 .channel_mode = alc880_asus_modes,
5110                 .need_dac_fix = 1,
5111                 .input_mux = &alc880_capture_source,
5112         },
5113         [ALC880_ASUS_W1V] = {
5114                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
5115                 .init_verbs = { alc880_volume_init_verbs,
5116                                 alc880_pin_asus_init_verbs,
5117                                 alc880_gpio1_init_verbs },
5118                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5119                 .dac_nids = alc880_asus_dac_nids,
5120                 .dig_out_nid = ALC880_DIGOUT_NID,
5121                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5122                 .channel_mode = alc880_asus_modes,
5123                 .need_dac_fix = 1,
5124                 .input_mux = &alc880_capture_source,
5125         },
5126         [ALC880_UNIWILL_DIG] = {
5127                 .mixers = { alc880_asus_mixer },
5128                 .init_verbs = { alc880_volume_init_verbs,
5129                                 alc880_pin_asus_init_verbs },
5130                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5131                 .dac_nids = alc880_asus_dac_nids,
5132                 .dig_out_nid = ALC880_DIGOUT_NID,
5133                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5134                 .channel_mode = alc880_asus_modes,
5135                 .need_dac_fix = 1,
5136                 .input_mux = &alc880_capture_source,
5137         },
5138         [ALC880_UNIWILL] = {
5139                 .mixers = { alc880_uniwill_mixer },
5140                 .init_verbs = { alc880_volume_init_verbs,
5141                                 alc880_uniwill_init_verbs },
5142                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5143                 .dac_nids = alc880_asus_dac_nids,
5144                 .dig_out_nid = ALC880_DIGOUT_NID,
5145                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
5146                 .channel_mode = alc880_threestack_modes,
5147                 .need_dac_fix = 1,
5148                 .input_mux = &alc880_capture_source,
5149                 .unsol_event = alc880_uniwill_unsol_event,
5150                 .setup = alc880_uniwill_setup,
5151                 .init_hook = alc880_uniwill_init_hook,
5152         },
5153         [ALC880_UNIWILL_P53] = {
5154                 .mixers = { alc880_uniwill_p53_mixer },
5155                 .init_verbs = { alc880_volume_init_verbs,
5156                                 alc880_uniwill_p53_init_verbs },
5157                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5158                 .dac_nids = alc880_asus_dac_nids,
5159                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
5160                 .channel_mode = alc880_threestack_modes,
5161                 .input_mux = &alc880_capture_source,
5162                 .unsol_event = alc880_uniwill_p53_unsol_event,
5163                 .setup = alc880_uniwill_p53_setup,
5164                 .init_hook = alc_hp_automute,
5165         },
5166         [ALC880_FUJITSU] = {
5167                 .mixers = { alc880_fujitsu_mixer },
5168                 .init_verbs = { alc880_volume_init_verbs,
5169                                 alc880_uniwill_p53_init_verbs,
5170                                 alc880_beep_init_verbs },
5171                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5172                 .dac_nids = alc880_dac_nids,
5173                 .dig_out_nid = ALC880_DIGOUT_NID,
5174                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5175                 .channel_mode = alc880_2_jack_modes,
5176                 .input_mux = &alc880_capture_source,
5177                 .unsol_event = alc880_uniwill_p53_unsol_event,
5178                 .setup = alc880_uniwill_p53_setup,
5179                 .init_hook = alc_hp_automute,
5180         },
5181         [ALC880_CLEVO] = {
5182                 .mixers = { alc880_three_stack_mixer },
5183                 .init_verbs = { alc880_volume_init_verbs,
5184                                 alc880_pin_clevo_init_verbs },
5185                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5186                 .dac_nids = alc880_dac_nids,
5187                 .hp_nid = 0x03,
5188                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
5189                 .channel_mode = alc880_threestack_modes,
5190                 .need_dac_fix = 1,
5191                 .input_mux = &alc880_capture_source,
5192         },
5193         [ALC880_LG] = {
5194                 .mixers = { alc880_lg_mixer },
5195                 .init_verbs = { alc880_volume_init_verbs,
5196                                 alc880_lg_init_verbs },
5197                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
5198                 .dac_nids = alc880_lg_dac_nids,
5199                 .dig_out_nid = ALC880_DIGOUT_NID,
5200                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
5201                 .channel_mode = alc880_lg_ch_modes,
5202                 .need_dac_fix = 1,
5203                 .input_mux = &alc880_lg_capture_source,
5204                 .unsol_event = alc_sku_unsol_event,
5205                 .setup = alc880_lg_setup,
5206                 .init_hook = alc_hp_automute,
5207 #ifdef CONFIG_SND_HDA_POWER_SAVE
5208                 .loopbacks = alc880_lg_loopbacks,
5209 #endif
5210         },
5211         [ALC880_LG_LW] = {
5212                 .mixers = { alc880_lg_lw_mixer },
5213                 .init_verbs = { alc880_volume_init_verbs,
5214                                 alc880_lg_lw_init_verbs },
5215                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5216                 .dac_nids = alc880_dac_nids,
5217                 .dig_out_nid = ALC880_DIGOUT_NID,
5218                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
5219                 .channel_mode = alc880_lg_lw_modes,
5220                 .input_mux = &alc880_lg_lw_capture_source,
5221                 .unsol_event = alc_sku_unsol_event,
5222                 .setup = alc880_lg_lw_setup,
5223                 .init_hook = alc_hp_automute,
5224         },
5225         [ALC880_MEDION_RIM] = {
5226                 .mixers = { alc880_medion_rim_mixer },
5227                 .init_verbs = { alc880_volume_init_verbs,
5228                                 alc880_medion_rim_init_verbs,
5229                                 alc_gpio2_init_verbs },
5230                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5231                 .dac_nids = alc880_dac_nids,
5232                 .dig_out_nid = ALC880_DIGOUT_NID,
5233                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5234                 .channel_mode = alc880_2_jack_modes,
5235                 .input_mux = &alc880_medion_rim_capture_source,
5236                 .unsol_event = alc880_medion_rim_unsol_event,
5237                 .setup = alc880_medion_rim_setup,
5238                 .init_hook = alc880_medion_rim_automute,
5239         },
5240 #ifdef CONFIG_SND_DEBUG
5241         [ALC880_TEST] = {
5242                 .mixers = { alc880_test_mixer },
5243                 .init_verbs = { alc880_test_init_verbs },
5244                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
5245                 .dac_nids = alc880_test_dac_nids,
5246                 .dig_out_nid = ALC880_DIGOUT_NID,
5247                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
5248                 .channel_mode = alc880_test_modes,
5249                 .input_mux = &alc880_test_capture_source,
5250         },
5251 #endif
5252 };
5253
5254 /*
5255  * Automatic parse of I/O pins from the BIOS configuration
5256  */
5257
5258 enum {
5259         ALC_CTL_WIDGET_VOL,
5260         ALC_CTL_WIDGET_MUTE,
5261         ALC_CTL_BIND_MUTE,
5262 };
5263 static const struct snd_kcontrol_new alc880_control_templates[] = {
5264         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
5265         HDA_CODEC_MUTE(NULL, 0, 0, 0),
5266         HDA_BIND_MUTE(NULL, 0, 0, 0),
5267 };
5268
5269 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
5270 {
5271         snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
5272         return snd_array_new(&spec->kctls);
5273 }
5274
5275 /* add dynamic controls */
5276 static int add_control(struct alc_spec *spec, int type, const char *name,
5277                        int cidx, unsigned long val)
5278 {
5279         struct snd_kcontrol_new *knew;
5280
5281         knew = alc_kcontrol_new(spec);
5282         if (!knew)
5283                 return -ENOMEM;
5284         *knew = alc880_control_templates[type];
5285         knew->name = kstrdup(name, GFP_KERNEL);
5286         if (!knew->name)
5287                 return -ENOMEM;
5288         knew->index = cidx;
5289         if (get_amp_nid_(val))
5290                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5291         knew->private_value = val;
5292         return 0;
5293 }
5294
5295 static int add_control_with_pfx(struct alc_spec *spec, int type,
5296                                 const char *pfx, const char *dir,
5297                                 const char *sfx, int cidx, unsigned long val)
5298 {
5299         char name[32];
5300         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5301         return add_control(spec, type, name, cidx, val);
5302 }
5303
5304 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
5305         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5306 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
5307         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5308 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
5309         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5310 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
5311         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5312
5313 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
5314 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
5315 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
5316 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
5317 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
5318 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
5319 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
5320 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
5321 #define ALC880_PIN_CD_NID               0x1c
5322
5323 /* fill in the dac_nids table from the parsed pin configuration */
5324 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5325                                      const struct auto_pin_cfg *cfg)
5326 {
5327         hda_nid_t nid;
5328         int assigned[4];
5329         int i, j;
5330
5331         memset(assigned, 0, sizeof(assigned));
5332         spec->multiout.dac_nids = spec->private_dac_nids;
5333
5334         /* check the pins hardwired to audio widget */
5335         for (i = 0; i < cfg->line_outs; i++) {
5336                 nid = cfg->line_out_pins[i];
5337                 if (alc880_is_fixed_pin(nid)) {
5338                         int idx = alc880_fixed_pin_idx(nid);
5339                         spec->private_dac_nids[i] = alc880_idx_to_dac(idx);
5340                         assigned[idx] = 1;
5341                 }
5342         }
5343         /* left pins can be connect to any audio widget */
5344         for (i = 0; i < cfg->line_outs; i++) {
5345                 nid = cfg->line_out_pins[i];
5346                 if (alc880_is_fixed_pin(nid))
5347                         continue;
5348                 /* search for an empty channel */
5349                 for (j = 0; j < cfg->line_outs; j++) {
5350                         if (!assigned[j]) {
5351                                 spec->private_dac_nids[i] =
5352                                         alc880_idx_to_dac(j);
5353                                 assigned[j] = 1;
5354                                 break;
5355                         }
5356                 }
5357         }
5358         spec->multiout.num_dacs = cfg->line_outs;
5359         return 0;
5360 }
5361
5362 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
5363                                         bool can_be_master, int *index)
5364 {
5365         struct auto_pin_cfg *cfg = &spec->autocfg;
5366         static const char * const chname[4] = {
5367                 "Front", "Surround", NULL /*CLFE*/, "Side"
5368         };
5369
5370         *index = 0;
5371         if (cfg->line_outs == 1 && !spec->multi_ios &&
5372             !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
5373                 return "Master";
5374
5375         switch (cfg->line_out_type) {
5376         case AUTO_PIN_SPEAKER_OUT:
5377                 if (cfg->line_outs == 1)
5378                         return "Speaker";
5379                 break;
5380         case AUTO_PIN_HP_OUT:
5381                 /* for multi-io case, only the primary out */
5382                 if (ch && spec->multi_ios)
5383                         break;
5384                 *index = ch;
5385                 return "Headphone";
5386         default:
5387                 if (cfg->line_outs == 1 && !spec->multi_ios)
5388                         return "PCM";
5389                 break;
5390         }
5391         return chname[ch];
5392 }
5393
5394 /* add playback controls from the parsed DAC table */
5395 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5396                                              const struct auto_pin_cfg *cfg)
5397 {
5398         hda_nid_t nid;
5399         int i, err, noutputs;
5400
5401         noutputs = cfg->line_outs;
5402         if (spec->multi_ios > 0)
5403                 noutputs += spec->multi_ios;
5404
5405         for (i = 0; i < noutputs; i++) {
5406                 const char *name;
5407                 int index;
5408                 if (!spec->multiout.dac_nids[i])
5409                         continue;
5410                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5411                 name = alc_get_line_out_pfx(spec, i, false, &index);
5412                 if (!name) {
5413                         /* Center/LFE */
5414                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5415                                               "Center",
5416                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5417                                                               HDA_OUTPUT));
5418                         if (err < 0)
5419                                 return err;
5420                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5421                                               "LFE",
5422                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5423                                                               HDA_OUTPUT));
5424                         if (err < 0)
5425                                 return err;
5426                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5427                                              "Center",
5428                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5429                                                               HDA_INPUT));
5430                         if (err < 0)
5431                                 return err;
5432                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5433                                              "LFE",
5434                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5435                                                               HDA_INPUT));
5436                         if (err < 0)
5437                                 return err;
5438                 } else {
5439                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5440                                                 name, index,
5441                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5442                                                               HDA_OUTPUT));
5443                         if (err < 0)
5444                                 return err;
5445                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5446                                                name, index,
5447                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5448                                                               HDA_INPUT));
5449                         if (err < 0)
5450                                 return err;
5451                 }
5452         }
5453         return 0;
5454 }
5455
5456 /* add playback controls for speaker and HP outputs */
5457 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5458                                         const char *pfx)
5459 {
5460         hda_nid_t nid;
5461         int err;
5462
5463         if (!pin)
5464                 return 0;
5465
5466         if (alc880_is_fixed_pin(pin)) {
5467                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5468                 /* specify the DAC as the extra output */
5469                 if (!spec->multiout.hp_nid)
5470                         spec->multiout.hp_nid = nid;
5471                 else
5472                         spec->multiout.extra_out_nid[0] = nid;
5473                 /* control HP volume/switch on the output mixer amp */
5474                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5475                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5476                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5477                 if (err < 0)
5478                         return err;
5479                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5480                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5481                 if (err < 0)
5482                         return err;
5483         } else if (alc880_is_multi_pin(pin)) {
5484                 /* set manual connection */
5485                 /* we have only a switch on HP-out PIN */
5486                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5487                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5488                 if (err < 0)
5489                         return err;
5490         }
5491         return 0;
5492 }
5493
5494 /* create input playback/capture controls for the given pin */
5495 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5496                             const char *ctlname, int ctlidx,
5497                             int idx, hda_nid_t mix_nid)
5498 {
5499         int err;
5500
5501         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5502                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5503         if (err < 0)
5504                 return err;
5505         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5506                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5507         if (err < 0)
5508                 return err;
5509         return 0;
5510 }
5511
5512 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5513 {
5514         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5515         return (pincap & AC_PINCAP_IN) != 0;
5516 }
5517
5518 /* create playback/capture controls for input pins */
5519 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5520                                       const struct auto_pin_cfg *cfg,
5521                                       hda_nid_t mixer,
5522                                       hda_nid_t cap1, hda_nid_t cap2)
5523 {
5524         struct alc_spec *spec = codec->spec;
5525         struct hda_input_mux *imux = &spec->private_imux[0];
5526         int i, err, idx, type_idx = 0;
5527         const char *prev_label = NULL;
5528
5529         for (i = 0; i < cfg->num_inputs; i++) {
5530                 hda_nid_t pin;
5531                 const char *label;
5532
5533                 pin = cfg->inputs[i].pin;
5534                 if (!alc_is_input_pin(codec, pin))
5535                         continue;
5536
5537                 label = hda_get_autocfg_input_label(codec, cfg, i);
5538                 if (prev_label && !strcmp(label, prev_label))
5539                         type_idx++;
5540                 else
5541                         type_idx = 0;
5542                 prev_label = label;
5543
5544                 if (mixer) {
5545                         idx = get_connection_index(codec, mixer, pin);
5546                         if (idx >= 0) {
5547                                 err = new_analog_input(spec, pin,
5548                                                        label, type_idx,
5549                                                        idx, mixer);
5550                                 if (err < 0)
5551                                         return err;
5552                         }
5553                 }
5554
5555                 if (!cap1)
5556                         continue;
5557                 idx = get_connection_index(codec, cap1, pin);
5558                 if (idx < 0 && cap2)
5559                         idx = get_connection_index(codec, cap2, pin);
5560                 if (idx >= 0)
5561                         snd_hda_add_imux_item(imux, label, idx, NULL);
5562         }
5563         return 0;
5564 }
5565
5566 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5567                                                 const struct auto_pin_cfg *cfg)
5568 {
5569         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5570 }
5571
5572 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5573                                unsigned int pin_type)
5574 {
5575         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5576                             pin_type);
5577         /* unmute pin */
5578         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5579                             AMP_OUT_UNMUTE);
5580 }
5581
5582 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5583                                               hda_nid_t nid, int pin_type,
5584                                               int dac_idx)
5585 {
5586         alc_set_pin_output(codec, nid, pin_type);
5587         /* need the manual connection? */
5588         if (alc880_is_multi_pin(nid)) {
5589                 struct alc_spec *spec = codec->spec;
5590                 int idx = alc880_multi_pin_idx(nid);
5591                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5592                                     AC_VERB_SET_CONNECT_SEL,
5593                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5594         }
5595 }
5596
5597 static int get_pin_type(int line_out_type)
5598 {
5599         if (line_out_type == AUTO_PIN_HP_OUT)
5600                 return PIN_HP;
5601         else
5602                 return PIN_OUT;
5603 }
5604
5605 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5606 {
5607         struct alc_spec *spec = codec->spec;
5608         int i;
5609
5610         for (i = 0; i < spec->autocfg.line_outs; i++) {
5611                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5612                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5613                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5614         }
5615 }
5616
5617 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5618 {
5619         struct alc_spec *spec = codec->spec;
5620         hda_nid_t pin;
5621
5622         pin = spec->autocfg.speaker_pins[0];
5623         if (pin) /* connect to front */
5624                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5625         pin = spec->autocfg.hp_pins[0];
5626         if (pin) /* connect to front */
5627                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5628 }
5629
5630 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5631 {
5632         struct alc_spec *spec = codec->spec;
5633         struct auto_pin_cfg *cfg = &spec->autocfg;
5634         int i;
5635
5636         for (i = 0; i < cfg->num_inputs; i++) {
5637                 hda_nid_t nid = cfg->inputs[i].pin;
5638                 if (alc_is_input_pin(codec, nid)) {
5639                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5640                         if (nid != ALC880_PIN_CD_NID &&
5641                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5642                                 snd_hda_codec_write(codec, nid, 0,
5643                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5644                                                     AMP_OUT_MUTE);
5645                 }
5646         }
5647 }
5648
5649 static void alc880_auto_init_input_src(struct hda_codec *codec)
5650 {
5651         struct alc_spec *spec = codec->spec;
5652         int c;
5653
5654         for (c = 0; c < spec->num_adc_nids; c++) {
5655                 unsigned int mux_idx;
5656                 const struct hda_input_mux *imux;
5657                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5658                 imux = &spec->input_mux[mux_idx];
5659                 if (!imux->num_items && mux_idx > 0)
5660                         imux = &spec->input_mux[0];
5661                 if (imux)
5662                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5663                                             AC_VERB_SET_CONNECT_SEL,
5664                                             imux->items[0].index);
5665         }
5666 }
5667
5668 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec);
5669
5670 /* parse the BIOS configuration and set up the alc_spec */
5671 /* return 1 if successful, 0 if the proper config is not found,
5672  * or a negative error code
5673  */
5674 static int alc880_parse_auto_config(struct hda_codec *codec)
5675 {
5676         struct alc_spec *spec = codec->spec;
5677         int err;
5678         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5679
5680         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5681                                            alc880_ignore);
5682         if (err < 0)
5683                 return err;
5684         if (!spec->autocfg.line_outs)
5685                 return 0; /* can't find valid BIOS pin config */
5686
5687         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5688         if (err < 0)
5689                 return err;
5690         err = alc_auto_add_multi_channel_mode(codec);
5691         if (err < 0)
5692                 return err;
5693         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5694         if (err < 0)
5695                 return err;
5696         err = alc880_auto_create_extra_out(spec,
5697                                            spec->autocfg.speaker_pins[0],
5698                                            "Speaker");
5699         if (err < 0)
5700                 return err;
5701         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5702                                            "Headphone");
5703         if (err < 0)
5704                 return err;
5705         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5706         if (err < 0)
5707                 return err;
5708
5709         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5710
5711         alc_auto_parse_digital(codec);
5712
5713         if (spec->kctls.list)
5714                 add_mixer(spec, spec->kctls.list);
5715
5716         add_verb(spec, alc880_volume_init_verbs);
5717
5718         spec->num_mux_defs = 1;
5719         spec->input_mux = &spec->private_imux[0];
5720
5721         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5722
5723         return 1;
5724 }
5725
5726 /* additional initialization for auto-configuration model */
5727 static void alc880_auto_init(struct hda_codec *codec)
5728 {
5729         struct alc_spec *spec = codec->spec;
5730         alc880_auto_init_multi_out(codec);
5731         alc880_auto_init_extra_out(codec);
5732         alc880_auto_init_analog_input(codec);
5733         alc880_auto_init_input_src(codec);
5734         alc_auto_init_digital(codec);
5735         if (spec->unsol_event)
5736                 alc_inithook(codec);
5737 }
5738
5739 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5740  * one of two digital mic pins, e.g. on ALC272
5741  */
5742 static void fixup_automic_adc(struct hda_codec *codec)
5743 {
5744         struct alc_spec *spec = codec->spec;
5745         int i;
5746
5747         for (i = 0; i < spec->num_adc_nids; i++) {
5748                 hda_nid_t cap = spec->capsrc_nids ?
5749                         spec->capsrc_nids[i] : spec->adc_nids[i];
5750                 int iidx, eidx;
5751
5752                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5753                 if (iidx < 0)
5754                         continue;
5755                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5756                 if (eidx < 0)
5757                         continue;
5758                 spec->int_mic.mux_idx = iidx;
5759                 spec->ext_mic.mux_idx = eidx;
5760                 if (spec->capsrc_nids)
5761                         spec->capsrc_nids += i;
5762                 spec->adc_nids += i;
5763                 spec->num_adc_nids = 1;
5764                 /* optional dock-mic */
5765                 eidx = get_connection_index(codec, cap, spec->dock_mic.pin);
5766                 if (eidx < 0)
5767                         spec->dock_mic.pin = 0;
5768                 else
5769                         spec->dock_mic.mux_idx = eidx;
5770                 return;
5771         }
5772         snd_printd(KERN_INFO "hda_codec: %s: "
5773                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5774                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5775         spec->auto_mic = 0; /* disable auto-mic to be sure */
5776 }
5777
5778 /* select or unmute the given capsrc route */
5779 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5780                                     int idx)
5781 {
5782         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5783                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5784                                          HDA_AMP_MUTE, 0);
5785         } else {
5786                 snd_hda_codec_write_cache(codec, cap, 0,
5787                                           AC_VERB_SET_CONNECT_SEL, idx);
5788         }
5789 }
5790
5791 /* set the default connection to that pin */
5792 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5793 {
5794         struct alc_spec *spec = codec->spec;
5795         int i;
5796
5797         if (!pin)
5798                 return 0;
5799         for (i = 0; i < spec->num_adc_nids; i++) {
5800                 hda_nid_t cap = spec->capsrc_nids ?
5801                         spec->capsrc_nids[i] : spec->adc_nids[i];
5802                 int idx;
5803
5804                 idx = get_connection_index(codec, cap, pin);
5805                 if (idx < 0)
5806                         continue;
5807                 select_or_unmute_capsrc(codec, cap, idx);
5808                 return i; /* return the found index */
5809         }
5810         return -1; /* not found */
5811 }
5812
5813 /* choose the ADC/MUX containing the input pin and initialize the setup */
5814 static void fixup_single_adc(struct hda_codec *codec)
5815 {
5816         struct alc_spec *spec = codec->spec;
5817         struct auto_pin_cfg *cfg = &spec->autocfg;
5818         int i;
5819
5820         /* search for the input pin; there must be only one */
5821         if (cfg->num_inputs != 1)
5822                 return;
5823         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5824         if (i >= 0) {
5825                 /* use only this ADC */
5826                 if (spec->capsrc_nids)
5827                         spec->capsrc_nids += i;
5828                 spec->adc_nids += i;
5829                 spec->num_adc_nids = 1;
5830                 spec->single_input_src = 1;
5831         }
5832 }
5833
5834 /* initialize dual adcs */
5835 static void fixup_dual_adc_switch(struct hda_codec *codec)
5836 {
5837         struct alc_spec *spec = codec->spec;
5838         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5839         init_capsrc_for_pin(codec, spec->dock_mic.pin);
5840         init_capsrc_for_pin(codec, spec->int_mic.pin);
5841 }
5842
5843 /* initialize some special cases for input sources */
5844 static void alc_init_special_input_src(struct hda_codec *codec)
5845 {
5846         struct alc_spec *spec = codec->spec;
5847         if (spec->dual_adc_switch)
5848                 fixup_dual_adc_switch(codec);
5849         else if (spec->single_input_src)
5850                 init_capsrc_for_pin(codec, spec->autocfg.inputs[0].pin);
5851 }
5852
5853 static void set_capture_mixer(struct hda_codec *codec)
5854 {
5855         struct alc_spec *spec = codec->spec;
5856         static const struct snd_kcontrol_new *caps[2][3] = {
5857                 { alc_capture_mixer_nosrc1,
5858                   alc_capture_mixer_nosrc2,
5859                   alc_capture_mixer_nosrc3 },
5860                 { alc_capture_mixer1,
5861                   alc_capture_mixer2,
5862                   alc_capture_mixer3 },
5863         };
5864         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5865                 int mux = 0;
5866                 int num_adcs = spec->num_adc_nids;
5867                 if (spec->dual_adc_switch)
5868                         num_adcs = 1;
5869                 else if (spec->auto_mic)
5870                         fixup_automic_adc(codec);
5871                 else if (spec->input_mux) {
5872                         if (spec->input_mux->num_items > 1)
5873                                 mux = 1;
5874                         else if (spec->input_mux->num_items == 1)
5875                                 fixup_single_adc(codec);
5876                 }
5877                 spec->cap_mixer = caps[mux][num_adcs - 1];
5878         }
5879 }
5880
5881 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5882 static void fillup_priv_adc_nids(struct hda_codec *codec, const hda_nid_t *nids,
5883                                  int num_nids)
5884 {
5885         struct alc_spec *spec = codec->spec;
5886         struct auto_pin_cfg *cfg = &spec->autocfg;
5887         int n;
5888         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5889
5890         for (n = 0; n < num_nids; n++) {
5891                 hda_nid_t adc, cap;
5892                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5893                 int nconns, i, j;
5894
5895                 adc = nids[n];
5896                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5897                         continue;
5898                 cap = adc;
5899                 nconns = snd_hda_get_connections(codec, cap, conn,
5900                                                  ARRAY_SIZE(conn));
5901                 if (nconns == 1) {
5902                         cap = conn[0];
5903                         nconns = snd_hda_get_connections(codec, cap, conn,
5904                                                          ARRAY_SIZE(conn));
5905                 }
5906                 if (nconns <= 0)
5907                         continue;
5908                 if (!fallback_adc) {
5909                         fallback_adc = adc;
5910                         fallback_cap = cap;
5911                 }
5912                 for (i = 0; i < cfg->num_inputs; i++) {
5913                         hda_nid_t nid = cfg->inputs[i].pin;
5914                         for (j = 0; j < nconns; j++) {
5915                                 if (conn[j] == nid)
5916                                         break;
5917                         }
5918                         if (j >= nconns)
5919                                 break;
5920                 }
5921                 if (i >= cfg->num_inputs) {
5922                         int num_adcs = spec->num_adc_nids;
5923                         spec->private_adc_nids[num_adcs] = adc;
5924                         spec->private_capsrc_nids[num_adcs] = cap;
5925                         spec->num_adc_nids++;
5926                         spec->adc_nids = spec->private_adc_nids;
5927                         if (adc != cap)
5928                                 spec->capsrc_nids = spec->private_capsrc_nids;
5929                 }
5930         }
5931         if (!spec->num_adc_nids) {
5932                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5933                        " using fallback 0x%x\n",
5934                        codec->chip_name, fallback_adc);
5935                 spec->private_adc_nids[0] = fallback_adc;
5936                 spec->adc_nids = spec->private_adc_nids;
5937                 if (fallback_adc != fallback_cap) {
5938                         spec->private_capsrc_nids[0] = fallback_cap;
5939                         spec->capsrc_nids = spec->private_adc_nids;
5940                 }
5941         }
5942 }
5943
5944 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5945 #define set_beep_amp(spec, nid, idx, dir) \
5946         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5947
5948 static const struct snd_pci_quirk beep_white_list[] = {
5949         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5950         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5951         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
5952         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
5953         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5954         {}
5955 };
5956
5957 static inline int has_cdefine_beep(struct hda_codec *codec)
5958 {
5959         struct alc_spec *spec = codec->spec;
5960         const struct snd_pci_quirk *q;
5961         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5962         if (q)
5963                 return q->value;
5964         return spec->cdefine.enable_pcbeep;
5965 }
5966 #else
5967 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5968 #define has_cdefine_beep(codec)         0
5969 #endif
5970
5971 /*
5972  * OK, here we have finally the patch for ALC880
5973  */
5974
5975 static int patch_alc880(struct hda_codec *codec)
5976 {
5977         struct alc_spec *spec;
5978         int board_config;
5979         int err;
5980
5981         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5982         if (spec == NULL)
5983                 return -ENOMEM;
5984
5985         codec->spec = spec;
5986
5987         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5988                                                   alc880_models,
5989                                                   alc880_cfg_tbl);
5990         if (board_config < 0) {
5991                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5992                        codec->chip_name);
5993                 board_config = ALC880_AUTO;
5994         }
5995
5996         if (board_config == ALC880_AUTO) {
5997                 /* automatic parse from the BIOS config */
5998                 err = alc880_parse_auto_config(codec);
5999                 if (err < 0) {
6000                         alc_free(codec);
6001                         return err;
6002                 } else if (!err) {
6003                         printk(KERN_INFO
6004                                "hda_codec: Cannot set up configuration "
6005                                "from BIOS.  Using 3-stack mode...\n");
6006                         board_config = ALC880_3ST;
6007                 }
6008         }
6009
6010         err = snd_hda_attach_beep_device(codec, 0x1);
6011         if (err < 0) {
6012                 alc_free(codec);
6013                 return err;
6014         }
6015
6016         if (board_config != ALC880_AUTO)
6017                 setup_preset(codec, &alc880_presets[board_config]);
6018
6019         spec->stream_analog_playback = &alc880_pcm_analog_playback;
6020         spec->stream_analog_capture = &alc880_pcm_analog_capture;
6021         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6022
6023         spec->stream_digital_playback = &alc880_pcm_digital_playback;
6024         spec->stream_digital_capture = &alc880_pcm_digital_capture;
6025
6026         if (!spec->adc_nids && spec->input_mux) {
6027                 /* check whether NID 0x07 is valid */
6028                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
6029                 /* get type */
6030                 wcap = get_wcaps_type(wcap);
6031                 if (wcap != AC_WID_AUD_IN) {
6032                         spec->adc_nids = alc880_adc_nids_alt;
6033                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
6034                 } else {
6035                         spec->adc_nids = alc880_adc_nids;
6036                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
6037                 }
6038         }
6039         set_capture_mixer(codec);
6040         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6041
6042         spec->vmaster_nid = 0x0c;
6043
6044         codec->patch_ops = alc_patch_ops;
6045         if (board_config == ALC880_AUTO)
6046                 spec->init_hook = alc880_auto_init;
6047 #ifdef CONFIG_SND_HDA_POWER_SAVE
6048         if (!spec->loopback.amplist)
6049                 spec->loopback.amplist = alc880_loopbacks;
6050 #endif
6051
6052         return 0;
6053 }
6054
6055
6056 /*
6057  * ALC260 support
6058  */
6059
6060 static const hda_nid_t alc260_dac_nids[1] = {
6061         /* front */
6062         0x02,
6063 };
6064
6065 static const hda_nid_t alc260_adc_nids[1] = {
6066         /* ADC0 */
6067         0x04,
6068 };
6069
6070 static const hda_nid_t alc260_adc_nids_alt[1] = {
6071         /* ADC1 */
6072         0x05,
6073 };
6074
6075 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
6076  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
6077  */
6078 static const hda_nid_t alc260_dual_adc_nids[2] = {
6079         /* ADC0, ADC1 */
6080         0x04, 0x05
6081 };
6082
6083 #define ALC260_DIGOUT_NID       0x03
6084 #define ALC260_DIGIN_NID        0x06
6085
6086 static const struct hda_input_mux alc260_capture_source = {
6087         .num_items = 4,
6088         .items = {
6089                 { "Mic", 0x0 },
6090                 { "Front Mic", 0x1 },
6091                 { "Line", 0x2 },
6092                 { "CD", 0x4 },
6093         },
6094 };
6095
6096 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
6097  * headphone jack and the internal CD lines since these are the only pins at
6098  * which audio can appear.  For flexibility, also allow the option of
6099  * recording the mixer output on the second ADC (ADC0 doesn't have a
6100  * connection to the mixer output).
6101  */
6102 static const struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
6103         {
6104                 .num_items = 3,
6105                 .items = {
6106                         { "Mic/Line", 0x0 },
6107                         { "CD", 0x4 },
6108                         { "Headphone", 0x2 },
6109                 },
6110         },
6111         {
6112                 .num_items = 4,
6113                 .items = {
6114                         { "Mic/Line", 0x0 },
6115                         { "CD", 0x4 },
6116                         { "Headphone", 0x2 },
6117                         { "Mixer", 0x5 },
6118                 },
6119         },
6120
6121 };
6122
6123 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
6124  * the Fujitsu S702x, but jacks are marked differently.
6125  */
6126 static const struct hda_input_mux alc260_acer_capture_sources[2] = {
6127         {
6128                 .num_items = 4,
6129                 .items = {
6130                         { "Mic", 0x0 },
6131                         { "Line", 0x2 },
6132                         { "CD", 0x4 },
6133                         { "Headphone", 0x5 },
6134                 },
6135         },
6136         {
6137                 .num_items = 5,
6138                 .items = {
6139                         { "Mic", 0x0 },
6140                         { "Line", 0x2 },
6141                         { "CD", 0x4 },
6142                         { "Headphone", 0x6 },
6143                         { "Mixer", 0x5 },
6144                 },
6145         },
6146 };
6147
6148 /* Maxdata Favorit 100XS */
6149 static const struct hda_input_mux alc260_favorit100_capture_sources[2] = {
6150         {
6151                 .num_items = 2,
6152                 .items = {
6153                         { "Line/Mic", 0x0 },
6154                         { "CD", 0x4 },
6155                 },
6156         },
6157         {
6158                 .num_items = 3,
6159                 .items = {
6160                         { "Line/Mic", 0x0 },
6161                         { "CD", 0x4 },
6162                         { "Mixer", 0x5 },
6163                 },
6164         },
6165 };
6166
6167 /*
6168  * This is just place-holder, so there's something for alc_build_pcms to look
6169  * at when it calculates the maximum number of channels. ALC260 has no mixer
6170  * element which allows changing the channel mode, so the verb list is
6171  * never used.
6172  */
6173 static const struct hda_channel_mode alc260_modes[1] = {
6174         { 2, NULL },
6175 };
6176
6177
6178 /* Mixer combinations
6179  *
6180  * basic: base_output + input + pc_beep + capture
6181  * HP: base_output + input + capture_alt
6182  * HP_3013: hp_3013 + input + capture
6183  * fujitsu: fujitsu + capture
6184  * acer: acer + capture
6185  */
6186
6187 static const struct snd_kcontrol_new alc260_base_output_mixer[] = {
6188         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6189         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
6190         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6191         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
6192         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6193         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6194         { } /* end */
6195 };
6196
6197 static const struct snd_kcontrol_new alc260_input_mixer[] = {
6198         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6199         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6200         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6201         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6202         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6203         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6204         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
6205         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
6206         { } /* end */
6207 };
6208
6209 /* update HP, line and mono out pins according to the master switch */
6210 static void alc260_hp_master_update(struct hda_codec *codec)
6211 {
6212         update_speakers(codec);
6213 }
6214
6215 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
6216                                    struct snd_ctl_elem_value *ucontrol)
6217 {
6218         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6219         struct alc_spec *spec = codec->spec;
6220         *ucontrol->value.integer.value = !spec->master_mute;
6221         return 0;
6222 }
6223
6224 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
6225                                    struct snd_ctl_elem_value *ucontrol)
6226 {
6227         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6228         struct alc_spec *spec = codec->spec;
6229         int val = !*ucontrol->value.integer.value;
6230
6231         if (val == spec->master_mute)
6232                 return 0;
6233         spec->master_mute = val;
6234         alc260_hp_master_update(codec);
6235         return 1;
6236 }
6237
6238 static const struct snd_kcontrol_new alc260_hp_output_mixer[] = {
6239         {
6240                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6241                 .name = "Master Playback Switch",
6242                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6243                 .info = snd_ctl_boolean_mono_info,
6244                 .get = alc260_hp_master_sw_get,
6245                 .put = alc260_hp_master_sw_put,
6246         },
6247         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6248         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
6249         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6250         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
6251         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6252                               HDA_OUTPUT),
6253         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6254         { } /* end */
6255 };
6256
6257 static const struct hda_verb alc260_hp_unsol_verbs[] = {
6258         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6259         {},
6260 };
6261
6262 static void alc260_hp_setup(struct hda_codec *codec)
6263 {
6264         struct alc_spec *spec = codec->spec;
6265
6266         spec->autocfg.hp_pins[0] = 0x0f;
6267         spec->autocfg.speaker_pins[0] = 0x10;
6268         spec->autocfg.speaker_pins[1] = 0x11;
6269         spec->automute = 1;
6270         spec->automute_mode = ALC_AUTOMUTE_PIN;
6271 }
6272
6273 static const struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
6274         {
6275                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6276                 .name = "Master Playback Switch",
6277                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6278                 .info = snd_ctl_boolean_mono_info,
6279                 .get = alc260_hp_master_sw_get,
6280                 .put = alc260_hp_master_sw_put,
6281         },
6282         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6283         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6284         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
6285         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
6286         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6287         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6288         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6289         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
6290         { } /* end */
6291 };
6292
6293 static void alc260_hp_3013_setup(struct hda_codec *codec)
6294 {
6295         struct alc_spec *spec = codec->spec;
6296
6297         spec->autocfg.hp_pins[0] = 0x15;
6298         spec->autocfg.speaker_pins[0] = 0x10;
6299         spec->autocfg.speaker_pins[1] = 0x11;
6300         spec->automute = 1;
6301         spec->automute_mode = ALC_AUTOMUTE_PIN;
6302 }
6303
6304 static const struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
6305         .ops = &snd_hda_bind_vol,
6306         .values = {
6307                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
6308                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
6309                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
6310                 0
6311         },
6312 };
6313
6314 static const struct hda_bind_ctls alc260_dc7600_bind_switch = {
6315         .ops = &snd_hda_bind_sw,
6316         .values = {
6317                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
6318                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
6319                 0
6320         },
6321 };
6322
6323 static const struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
6324         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
6325         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
6326         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
6327         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6328         { } /* end */
6329 };
6330
6331 static const struct hda_verb alc260_hp_3013_unsol_verbs[] = {
6332         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6333         {},
6334 };
6335
6336 static void alc260_hp_3012_setup(struct hda_codec *codec)
6337 {
6338         struct alc_spec *spec = codec->spec;
6339
6340         spec->autocfg.hp_pins[0] = 0x10;
6341         spec->autocfg.speaker_pins[0] = 0x0f;
6342         spec->autocfg.speaker_pins[1] = 0x11;
6343         spec->autocfg.speaker_pins[2] = 0x15;
6344         spec->automute = 1;
6345         spec->automute_mode = ALC_AUTOMUTE_PIN;
6346 }
6347
6348 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6349  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6350  */
6351 static const struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6352         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6353         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6354         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6355         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6356         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6357         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6358         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6359         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6360         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6361         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6362         { } /* end */
6363 };
6364
6365 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6366  * versions of the ALC260 don't act on requests to enable mic bias from NID
6367  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6368  * datasheet doesn't mention this restriction.  At this stage it's not clear
6369  * whether this behaviour is intentional or is a hardware bug in chip
6370  * revisions available in early 2006.  Therefore for now allow the
6371  * "Headphone Jack Mode" control to span all choices, but if it turns out
6372  * that the lack of mic bias for this NID is intentional we could change the
6373  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6374  *
6375  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6376  * don't appear to make the mic bias available from the "line" jack, even
6377  * though the NID used for this jack (0x14) can supply it.  The theory is
6378  * that perhaps Acer have included blocking capacitors between the ALC260
6379  * and the output jack.  If this turns out to be the case for all such
6380  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6381  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6382  *
6383  * The C20x Tablet series have a mono internal speaker which is controlled
6384  * via the chip's Mono sum widget and pin complex, so include the necessary
6385  * controls for such models.  On models without a "mono speaker" the control
6386  * won't do anything.
6387  */
6388 static const struct snd_kcontrol_new alc260_acer_mixer[] = {
6389         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6390         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6391         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6392         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6393                               HDA_OUTPUT),
6394         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6395                            HDA_INPUT),
6396         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6397         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6398         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6399         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6400         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6401         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6402         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6403         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6404         { } /* end */
6405 };
6406
6407 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6408  */
6409 static const struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6410         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6411         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6412         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6413         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6414         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6415         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6416         { } /* end */
6417 };
6418
6419 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6420  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6421  */
6422 static const struct snd_kcontrol_new alc260_will_mixer[] = {
6423         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6424         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6425         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6426         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6427         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6428         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6429         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6430         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6431         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6432         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6433         { } /* end */
6434 };
6435
6436 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6437  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6438  */
6439 static const struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6440         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6441         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6442         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6443         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6444         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6445         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6446         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6447         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6448         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6449         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6450         { } /* end */
6451 };
6452
6453 /*
6454  * initialization verbs
6455  */
6456 static const struct hda_verb alc260_init_verbs[] = {
6457         /* Line In pin widget for input */
6458         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6459         /* CD pin widget for input */
6460         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6461         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6462         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6463         /* Mic2 (front panel) pin widget for input and vref at 80% */
6464         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6465         /* LINE-2 is used for line-out in rear */
6466         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6467         /* select line-out */
6468         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6469         /* LINE-OUT pin */
6470         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6471         /* enable HP */
6472         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6473         /* enable Mono */
6474         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6475         /* mute capture amp left and right */
6476         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6477         /* set connection select to line in (default select for this ADC) */
6478         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6479         /* mute capture amp left and right */
6480         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6481         /* set connection select to line in (default select for this ADC) */
6482         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6483         /* set vol=0 Line-Out mixer amp left and right */
6484         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6485         /* unmute pin widget amp left and right (no gain on this amp) */
6486         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6487         /* set vol=0 HP mixer amp left and right */
6488         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6489         /* unmute pin widget amp left and right (no gain on this amp) */
6490         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6491         /* set vol=0 Mono mixer amp left and right */
6492         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6493         /* unmute pin widget amp left and right (no gain on this amp) */
6494         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6495         /* unmute LINE-2 out pin */
6496         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6497         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6498          * Line In 2 = 0x03
6499          */
6500         /* mute analog inputs */
6501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6502         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6503         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6504         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6505         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6506         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6507         /* mute Front out path */
6508         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6509         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6510         /* mute Headphone out path */
6511         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6512         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6513         /* mute Mono out path */
6514         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6515         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6516         { }
6517 };
6518
6519 #if 0 /* should be identical with alc260_init_verbs? */
6520 static const struct hda_verb alc260_hp_init_verbs[] = {
6521         /* Headphone and output */
6522         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6523         /* mono output */
6524         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6525         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6526         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6527         /* Mic2 (front panel) pin widget for input and vref at 80% */
6528         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6529         /* Line In pin widget for input */
6530         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6531         /* Line-2 pin widget for output */
6532         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6533         /* CD pin widget for input */
6534         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6535         /* unmute amp left and right */
6536         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6537         /* set connection select to line in (default select for this ADC) */
6538         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6539         /* unmute Line-Out mixer amp left and right (volume = 0) */
6540         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6541         /* mute pin widget amp left and right (no gain on this amp) */
6542         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6543         /* unmute HP mixer amp left and right (volume = 0) */
6544         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6545         /* mute pin widget amp left and right (no gain on this amp) */
6546         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6547         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6548          * Line In 2 = 0x03
6549          */
6550         /* mute analog inputs */
6551         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6552         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6553         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6554         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6555         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6556         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6557         /* Unmute Front out path */
6558         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6559         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6560         /* Unmute Headphone out path */
6561         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6562         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6563         /* Unmute Mono out path */
6564         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6565         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6566         { }
6567 };
6568 #endif
6569
6570 static const struct hda_verb alc260_hp_3013_init_verbs[] = {
6571         /* Line out and output */
6572         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6573         /* mono output */
6574         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6575         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6576         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6577         /* Mic2 (front panel) pin widget for input and vref at 80% */
6578         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6579         /* Line In pin widget for input */
6580         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6581         /* Headphone pin widget for output */
6582         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6583         /* CD pin widget for input */
6584         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6585         /* unmute amp left and right */
6586         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6587         /* set connection select to line in (default select for this ADC) */
6588         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6589         /* unmute Line-Out mixer amp left and right (volume = 0) */
6590         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6591         /* mute pin widget amp left and right (no gain on this amp) */
6592         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6593         /* unmute HP mixer amp left and right (volume = 0) */
6594         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6595         /* mute pin widget amp left and right (no gain on this amp) */
6596         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6597         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6598          * Line In 2 = 0x03
6599          */
6600         /* mute analog inputs */
6601         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6602         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6603         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6604         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6605         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6606         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6607         /* Unmute Front out path */
6608         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6609         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6610         /* Unmute Headphone out path */
6611         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6612         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6613         /* Unmute Mono out path */
6614         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6615         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6616         { }
6617 };
6618
6619 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6620  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6621  * audio = 0x16, internal speaker = 0x10.
6622  */
6623 static const struct hda_verb alc260_fujitsu_init_verbs[] = {
6624         /* Disable all GPIOs */
6625         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6626         /* Internal speaker is connected to headphone pin */
6627         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6628         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6629         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6630         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6631         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6632         /* Ensure all other unused pins are disabled and muted. */
6633         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6634         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6635         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6636         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6637         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6638         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6639         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6640         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6641
6642         /* Disable digital (SPDIF) pins */
6643         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6644         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6645
6646         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6647          * when acting as an output.
6648          */
6649         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6650
6651         /* Start with output sum widgets muted and their output gains at min */
6652         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6653         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6654         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6655         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6656         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6657         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6658         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6659         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6660         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6661
6662         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6663         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6664         /* Unmute Line1 pin widget output buffer since it starts as an output.
6665          * If the pin mode is changed by the user the pin mode control will
6666          * take care of enabling the pin's input/output buffers as needed.
6667          * Therefore there's no need to enable the input buffer at this
6668          * stage.
6669          */
6670         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6671         /* Unmute input buffer of pin widget used for Line-in (no equiv
6672          * mixer ctrl)
6673          */
6674         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6675
6676         /* Mute capture amp left and right */
6677         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6678         /* Set ADC connection select to match default mixer setting - line
6679          * in (on mic1 pin)
6680          */
6681         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6682
6683         /* Do the same for the second ADC: mute capture input amp and
6684          * set ADC connection to line in (on mic1 pin)
6685          */
6686         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6687         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6688
6689         /* Mute all inputs to mixer widget (even unconnected ones) */
6690         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6691         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6692         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6693         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6694         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6695         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6696         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6697         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6698
6699         { }
6700 };
6701
6702 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6703  * similar laptops (adapted from Fujitsu init verbs).
6704  */
6705 static const struct hda_verb alc260_acer_init_verbs[] = {
6706         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6707          * the headphone jack.  Turn this on and rely on the standard mute
6708          * methods whenever the user wants to turn these outputs off.
6709          */
6710         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6711         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6712         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6713         /* Internal speaker/Headphone jack is connected to Line-out pin */
6714         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6715         /* Internal microphone/Mic jack is connected to Mic1 pin */
6716         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6717         /* Line In jack is connected to Line1 pin */
6718         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6719         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6720         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6721         /* Ensure all other unused pins are disabled and muted. */
6722         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6723         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6724         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6725         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6726         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6727         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6728         /* Disable digital (SPDIF) pins */
6729         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6730         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6731
6732         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6733          * bus when acting as outputs.
6734          */
6735         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6736         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6737
6738         /* Start with output sum widgets muted and their output gains at min */
6739         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6740         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6741         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6742         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6743         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6744         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6745         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6746         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6747         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6748
6749         /* Unmute Line-out pin widget amp left and right
6750          * (no equiv mixer ctrl)
6751          */
6752         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6753         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6754         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6755         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6756          * inputs. If the pin mode is changed by the user the pin mode control
6757          * will take care of enabling the pin's input/output buffers as needed.
6758          * Therefore there's no need to enable the input buffer at this
6759          * stage.
6760          */
6761         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6762         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6763
6764         /* Mute capture amp left and right */
6765         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6766         /* Set ADC connection select to match default mixer setting - mic
6767          * (on mic1 pin)
6768          */
6769         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6770
6771         /* Do similar with the second ADC: mute capture input amp and
6772          * set ADC connection to mic to match ALSA's default state.
6773          */
6774         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6775         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6776
6777         /* Mute all inputs to mixer widget (even unconnected ones) */
6778         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6779         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6780         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6781         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6782         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6783         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6784         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6785         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6786
6787         { }
6788 };
6789
6790 /* Initialisation sequence for Maxdata Favorit 100XS
6791  * (adapted from Acer init verbs).
6792  */
6793 static const struct hda_verb alc260_favorit100_init_verbs[] = {
6794         /* GPIO 0 enables the output jack.
6795          * Turn this on and rely on the standard mute
6796          * methods whenever the user wants to turn these outputs off.
6797          */
6798         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6799         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6800         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6801         /* Line/Mic input jack is connected to Mic1 pin */
6802         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6803         /* Ensure all other unused pins are disabled and muted. */
6804         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6805         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6806         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6807         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6808         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6809         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6810         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6811         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6812         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6813         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6814         /* Disable digital (SPDIF) pins */
6815         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6816         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6817
6818         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6819          * bus when acting as outputs.
6820          */
6821         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6822         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6823
6824         /* Start with output sum widgets muted and their output gains at min */
6825         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6826         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6827         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6828         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6829         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6830         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6831         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6832         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6833         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6834
6835         /* Unmute Line-out pin widget amp left and right
6836          * (no equiv mixer ctrl)
6837          */
6838         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6839         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6840          * inputs. If the pin mode is changed by the user the pin mode control
6841          * will take care of enabling the pin's input/output buffers as needed.
6842          * Therefore there's no need to enable the input buffer at this
6843          * stage.
6844          */
6845         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6846
6847         /* Mute capture amp left and right */
6848         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6849         /* Set ADC connection select to match default mixer setting - mic
6850          * (on mic1 pin)
6851          */
6852         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6853
6854         /* Do similar with the second ADC: mute capture input amp and
6855          * set ADC connection to mic to match ALSA's default state.
6856          */
6857         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6858         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6859
6860         /* Mute all inputs to mixer widget (even unconnected ones) */
6861         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6862         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6863         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6864         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6865         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6866         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6867         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6868         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6869
6870         { }
6871 };
6872
6873 static const struct hda_verb alc260_will_verbs[] = {
6874         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6875         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6876         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6877         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6878         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6879         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6880         {}
6881 };
6882
6883 static const struct hda_verb alc260_replacer_672v_verbs[] = {
6884         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6885         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6886         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6887
6888         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6889         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6890         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6891
6892         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6893         {}
6894 };
6895
6896 /* toggle speaker-output according to the hp-jack state */
6897 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6898 {
6899         unsigned int present;
6900
6901         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6902         present = snd_hda_jack_detect(codec, 0x0f);
6903         if (present) {
6904                 snd_hda_codec_write_cache(codec, 0x01, 0,
6905                                           AC_VERB_SET_GPIO_DATA, 1);
6906                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6907                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6908                                           PIN_HP);
6909         } else {
6910                 snd_hda_codec_write_cache(codec, 0x01, 0,
6911                                           AC_VERB_SET_GPIO_DATA, 0);
6912                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6913                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6914                                           PIN_OUT);
6915         }
6916 }
6917
6918 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6919                                        unsigned int res)
6920 {
6921         if ((res >> 26) == ALC880_HP_EVENT)
6922                 alc260_replacer_672v_automute(codec);
6923 }
6924
6925 static const struct hda_verb alc260_hp_dc7600_verbs[] = {
6926         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6927         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6928         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6929         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6930         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6931         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6932         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6933         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6934         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6935         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6936         {}
6937 };
6938
6939 /* Test configuration for debugging, modelled after the ALC880 test
6940  * configuration.
6941  */
6942 #ifdef CONFIG_SND_DEBUG
6943 static const hda_nid_t alc260_test_dac_nids[1] = {
6944         0x02,
6945 };
6946 static const hda_nid_t alc260_test_adc_nids[2] = {
6947         0x04, 0x05,
6948 };
6949 /* For testing the ALC260, each input MUX needs its own definition since
6950  * the signal assignments are different.  This assumes that the first ADC
6951  * is NID 0x04.
6952  */
6953 static const struct hda_input_mux alc260_test_capture_sources[2] = {
6954         {
6955                 .num_items = 7,
6956                 .items = {
6957                         { "MIC1 pin", 0x0 },
6958                         { "MIC2 pin", 0x1 },
6959                         { "LINE1 pin", 0x2 },
6960                         { "LINE2 pin", 0x3 },
6961                         { "CD pin", 0x4 },
6962                         { "LINE-OUT pin", 0x5 },
6963                         { "HP-OUT pin", 0x6 },
6964                 },
6965         },
6966         {
6967                 .num_items = 8,
6968                 .items = {
6969                         { "MIC1 pin", 0x0 },
6970                         { "MIC2 pin", 0x1 },
6971                         { "LINE1 pin", 0x2 },
6972                         { "LINE2 pin", 0x3 },
6973                         { "CD pin", 0x4 },
6974                         { "Mixer", 0x5 },
6975                         { "LINE-OUT pin", 0x6 },
6976                         { "HP-OUT pin", 0x7 },
6977                 },
6978         },
6979 };
6980 static const struct snd_kcontrol_new alc260_test_mixer[] = {
6981         /* Output driver widgets */
6982         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6983         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6984         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6985         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6986         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6987         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6988
6989         /* Modes for retasking pin widgets
6990          * Note: the ALC260 doesn't seem to act on requests to enable mic
6991          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6992          * mention this restriction.  At this stage it's not clear whether
6993          * this behaviour is intentional or is a hardware bug in chip
6994          * revisions available at least up until early 2006.  Therefore for
6995          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6996          * choices, but if it turns out that the lack of mic bias for these
6997          * NIDs is intentional we could change their modes from
6998          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6999          */
7000         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
7001         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
7002         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
7003         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
7004         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
7005         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
7006
7007         /* Loopback mixer controls */
7008         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
7009         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
7010         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
7011         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
7012         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
7013         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
7014         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
7015         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
7016         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
7017         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
7018         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
7019         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
7020         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
7021         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
7022
7023         /* Controls for GPIO pins, assuming they are configured as outputs */
7024         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
7025         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
7026         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
7027         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
7028
7029         /* Switches to allow the digital IO pins to be enabled.  The datasheet
7030          * is ambigious as to which NID is which; testing on laptops which
7031          * make this output available should provide clarification.
7032          */
7033         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
7034         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
7035
7036         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
7037          * this output to turn on an external amplifier.
7038          */
7039         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
7040         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
7041
7042         { } /* end */
7043 };
7044 static const struct hda_verb alc260_test_init_verbs[] = {
7045         /* Enable all GPIOs as outputs with an initial value of 0 */
7046         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
7047         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
7048         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
7049
7050         /* Enable retasking pins as output, initially without power amp */
7051         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7052         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7053         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7054         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7055         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7056         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7057
7058         /* Disable digital (SPDIF) pins initially, but users can enable
7059          * them via a mixer switch.  In the case of SPDIF-out, this initverb
7060          * payload also sets the generation to 0, output to be in "consumer"
7061          * PCM format, copyright asserted, no pre-emphasis and no validity
7062          * control.
7063          */
7064         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
7065         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
7066
7067         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
7068          * OUT1 sum bus when acting as an output.
7069          */
7070         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
7071         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
7072         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
7073         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
7074
7075         /* Start with output sum widgets muted and their output gains at min */
7076         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7077         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7078         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7079         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7080         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7081         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7082         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7083         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7084         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7085
7086         /* Unmute retasking pin widget output buffers since the default
7087          * state appears to be output.  As the pin mode is changed by the
7088          * user the pin mode control will take care of enabling the pin's
7089          * input/output buffers as needed.
7090          */
7091         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7092         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7093         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7094         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7095         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7096         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7097         /* Also unmute the mono-out pin widget */
7098         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7099
7100         /* Mute capture amp left and right */
7101         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7102         /* Set ADC connection select to match default mixer setting (mic1
7103          * pin)
7104          */
7105         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7106
7107         /* Do the same for the second ADC: mute capture input amp and
7108          * set ADC connection to mic1 pin
7109          */
7110         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7111         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7112
7113         /* Mute all inputs to mixer widget (even unconnected ones) */
7114         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
7115         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
7116         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
7117         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
7118         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
7119         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
7120         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
7121         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
7122
7123         { }
7124 };
7125 #endif
7126
7127 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
7128 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
7129
7130 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
7131 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
7132
7133 /*
7134  * for BIOS auto-configuration
7135  */
7136
7137 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
7138                                         const char *pfx, int *vol_bits)
7139 {
7140         hda_nid_t nid_vol;
7141         unsigned long vol_val, sw_val;
7142         int err;
7143
7144         if (nid >= 0x0f && nid < 0x11) {
7145                 nid_vol = nid - 0x7;
7146                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
7147                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
7148         } else if (nid == 0x11) {
7149                 nid_vol = nid - 0x7;
7150                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
7151                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
7152         } else if (nid >= 0x12 && nid <= 0x15) {
7153                 nid_vol = 0x08;
7154                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
7155                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
7156         } else
7157                 return 0; /* N/A */
7158
7159         if (!(*vol_bits & (1 << nid_vol))) {
7160                 /* first control for the volume widget */
7161                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
7162                 if (err < 0)
7163                         return err;
7164                 *vol_bits |= (1 << nid_vol);
7165         }
7166         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
7167         if (err < 0)
7168                 return err;
7169         return 1;
7170 }
7171
7172 /* add playback controls from the parsed DAC table */
7173 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
7174                                              const struct auto_pin_cfg *cfg)
7175 {
7176         hda_nid_t nid;
7177         int err;
7178         int vols = 0;
7179
7180         spec->multiout.num_dacs = 1;
7181         spec->multiout.dac_nids = spec->private_dac_nids;
7182         spec->private_dac_nids[0] = 0x02;
7183
7184         nid = cfg->line_out_pins[0];
7185         if (nid) {
7186                 const char *pfx;
7187                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
7188                         pfx = "Master";
7189                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
7190                         pfx = "Speaker";
7191                 else
7192                         pfx = "Front";
7193                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
7194                 if (err < 0)
7195                         return err;
7196         }
7197
7198         nid = cfg->speaker_pins[0];
7199         if (nid) {
7200                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
7201                 if (err < 0)
7202                         return err;
7203         }
7204
7205         nid = cfg->hp_pins[0];
7206         if (nid) {
7207                 err = alc260_add_playback_controls(spec, nid, "Headphone",
7208                                                    &vols);
7209                 if (err < 0)
7210                         return err;
7211         }
7212         return 0;
7213 }
7214
7215 /* create playback/capture controls for input pins */
7216 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
7217                                                 const struct auto_pin_cfg *cfg)
7218 {
7219         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
7220 }
7221
7222 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
7223                                               hda_nid_t nid, int pin_type,
7224                                               int sel_idx)
7225 {
7226         alc_set_pin_output(codec, nid, pin_type);
7227         /* need the manual connection? */
7228         if (nid >= 0x12) {
7229                 int idx = nid - 0x12;
7230                 snd_hda_codec_write(codec, idx + 0x0b, 0,
7231                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
7232         }
7233 }
7234
7235 static void alc260_auto_init_multi_out(struct hda_codec *codec)
7236 {
7237         struct alc_spec *spec = codec->spec;
7238         hda_nid_t nid;
7239
7240         nid = spec->autocfg.line_out_pins[0];
7241         if (nid) {
7242                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7243                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
7244         }
7245
7246         nid = spec->autocfg.speaker_pins[0];
7247         if (nid)
7248                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
7249
7250         nid = spec->autocfg.hp_pins[0];
7251         if (nid)
7252                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
7253 }
7254
7255 #define ALC260_PIN_CD_NID               0x16
7256 static void alc260_auto_init_analog_input(struct hda_codec *codec)
7257 {
7258         struct alc_spec *spec = codec->spec;
7259         struct auto_pin_cfg *cfg = &spec->autocfg;
7260         int i;
7261
7262         for (i = 0; i < cfg->num_inputs; i++) {
7263                 hda_nid_t nid = cfg->inputs[i].pin;
7264                 if (nid >= 0x12) {
7265                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
7266                         if (nid != ALC260_PIN_CD_NID &&
7267                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
7268                                 snd_hda_codec_write(codec, nid, 0,
7269                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7270                                                     AMP_OUT_MUTE);
7271                 }
7272         }
7273 }
7274
7275 #define alc260_auto_init_input_src      alc880_auto_init_input_src
7276
7277 /*
7278  * generic initialization of ADC, input mixers and output mixers
7279  */
7280 static const struct hda_verb alc260_volume_init_verbs[] = {
7281         /*
7282          * Unmute ADC0-1 and set the default input to mic-in
7283          */
7284         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7285         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7286         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7287         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7288
7289         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7290          * mixer widget
7291          * Note: PASD motherboards uses the Line In 2 as the input for
7292          * front panel mic (mic 2)
7293          */
7294         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7295         /* mute analog inputs */
7296         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7297         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7298         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7299         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7300         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7301
7302         /*
7303          * Set up output mixers (0x08 - 0x0a)
7304          */
7305         /* set vol=0 to output mixers */
7306         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7307         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7308         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7309         /* set up input amps for analog loopback */
7310         /* Amp Indices: DAC = 0, mixer = 1 */
7311         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7312         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7313         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7314         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7315         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7316         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7317
7318         { }
7319 };
7320
7321 static int alc260_parse_auto_config(struct hda_codec *codec)
7322 {
7323         struct alc_spec *spec = codec->spec;
7324         int err;
7325         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
7326
7327         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7328                                            alc260_ignore);
7329         if (err < 0)
7330                 return err;
7331         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7332         if (err < 0)
7333                 return err;
7334         if (!spec->kctls.list)
7335                 return 0; /* can't find valid BIOS pin config */
7336         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7337         if (err < 0)
7338                 return err;
7339
7340         spec->multiout.max_channels = 2;
7341
7342         if (spec->autocfg.dig_outs)
7343                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7344         if (spec->kctls.list)
7345                 add_mixer(spec, spec->kctls.list);
7346
7347         add_verb(spec, alc260_volume_init_verbs);
7348
7349         spec->num_mux_defs = 1;
7350         spec->input_mux = &spec->private_imux[0];
7351
7352         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7353
7354         return 1;
7355 }
7356
7357 /* additional initialization for auto-configuration model */
7358 static void alc260_auto_init(struct hda_codec *codec)
7359 {
7360         struct alc_spec *spec = codec->spec;
7361         alc260_auto_init_multi_out(codec);
7362         alc260_auto_init_analog_input(codec);
7363         alc260_auto_init_input_src(codec);
7364         alc_auto_init_digital(codec);
7365         if (spec->unsol_event)
7366                 alc_inithook(codec);
7367 }
7368
7369 #ifdef CONFIG_SND_HDA_POWER_SAVE
7370 static const struct hda_amp_list alc260_loopbacks[] = {
7371         { 0x07, HDA_INPUT, 0 },
7372         { 0x07, HDA_INPUT, 1 },
7373         { 0x07, HDA_INPUT, 2 },
7374         { 0x07, HDA_INPUT, 3 },
7375         { 0x07, HDA_INPUT, 4 },
7376         { } /* end */
7377 };
7378 #endif
7379
7380 /*
7381  * Pin config fixes
7382  */
7383 enum {
7384         PINFIX_HP_DC5750,
7385 };
7386
7387 static const struct alc_fixup alc260_fixups[] = {
7388         [PINFIX_HP_DC5750] = {
7389                 .type = ALC_FIXUP_PINS,
7390                 .v.pins = (const struct alc_pincfg[]) {
7391                         { 0x11, 0x90130110 }, /* speaker */
7392                         { }
7393                 }
7394         },
7395 };
7396
7397 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
7398         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7399         {}
7400 };
7401
7402 /*
7403  * ALC260 configurations
7404  */
7405 static const char * const alc260_models[ALC260_MODEL_LAST] = {
7406         [ALC260_BASIC]          = "basic",
7407         [ALC260_HP]             = "hp",
7408         [ALC260_HP_3013]        = "hp-3013",
7409         [ALC260_HP_DC7600]      = "hp-dc7600",
7410         [ALC260_FUJITSU_S702X]  = "fujitsu",
7411         [ALC260_ACER]           = "acer",
7412         [ALC260_WILL]           = "will",
7413         [ALC260_REPLACER_672V]  = "replacer",
7414         [ALC260_FAVORIT100]     = "favorit100",
7415 #ifdef CONFIG_SND_DEBUG
7416         [ALC260_TEST]           = "test",
7417 #endif
7418         [ALC260_AUTO]           = "auto",
7419 };
7420
7421 static const struct snd_pci_quirk alc260_cfg_tbl[] = {
7422         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7423         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7424         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7425         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7426         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7427         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7428         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7429         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7430         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7431         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7432         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7433         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7434         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7435         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7436         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7437         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7438         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7439         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7440         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7441         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7442         {}
7443 };
7444
7445 static const struct alc_config_preset alc260_presets[] = {
7446         [ALC260_BASIC] = {
7447                 .mixers = { alc260_base_output_mixer,
7448                             alc260_input_mixer },
7449                 .init_verbs = { alc260_init_verbs },
7450                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7451                 .dac_nids = alc260_dac_nids,
7452                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7453                 .adc_nids = alc260_dual_adc_nids,
7454                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7455                 .channel_mode = alc260_modes,
7456                 .input_mux = &alc260_capture_source,
7457         },
7458         [ALC260_HP] = {
7459                 .mixers = { alc260_hp_output_mixer,
7460                             alc260_input_mixer },
7461                 .init_verbs = { alc260_init_verbs,
7462                                 alc260_hp_unsol_verbs },
7463                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7464                 .dac_nids = alc260_dac_nids,
7465                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7466                 .adc_nids = alc260_adc_nids_alt,
7467                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7468                 .channel_mode = alc260_modes,
7469                 .input_mux = &alc260_capture_source,
7470                 .unsol_event = alc_sku_unsol_event,
7471                 .setup = alc260_hp_setup,
7472                 .init_hook = alc_inithook,
7473         },
7474         [ALC260_HP_DC7600] = {
7475                 .mixers = { alc260_hp_dc7600_mixer,
7476                             alc260_input_mixer },
7477                 .init_verbs = { alc260_init_verbs,
7478                                 alc260_hp_dc7600_verbs },
7479                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7480                 .dac_nids = alc260_dac_nids,
7481                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7482                 .adc_nids = alc260_adc_nids_alt,
7483                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7484                 .channel_mode = alc260_modes,
7485                 .input_mux = &alc260_capture_source,
7486                 .unsol_event = alc_sku_unsol_event,
7487                 .setup = alc260_hp_3012_setup,
7488                 .init_hook = alc_inithook,
7489         },
7490         [ALC260_HP_3013] = {
7491                 .mixers = { alc260_hp_3013_mixer,
7492                             alc260_input_mixer },
7493                 .init_verbs = { alc260_hp_3013_init_verbs,
7494                                 alc260_hp_3013_unsol_verbs },
7495                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7496                 .dac_nids = alc260_dac_nids,
7497                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7498                 .adc_nids = alc260_adc_nids_alt,
7499                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7500                 .channel_mode = alc260_modes,
7501                 .input_mux = &alc260_capture_source,
7502                 .unsol_event = alc_sku_unsol_event,
7503                 .setup = alc260_hp_3013_setup,
7504                 .init_hook = alc_inithook,
7505         },
7506         [ALC260_FUJITSU_S702X] = {
7507                 .mixers = { alc260_fujitsu_mixer },
7508                 .init_verbs = { alc260_fujitsu_init_verbs },
7509                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7510                 .dac_nids = alc260_dac_nids,
7511                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7512                 .adc_nids = alc260_dual_adc_nids,
7513                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7514                 .channel_mode = alc260_modes,
7515                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7516                 .input_mux = alc260_fujitsu_capture_sources,
7517         },
7518         [ALC260_ACER] = {
7519                 .mixers = { alc260_acer_mixer },
7520                 .init_verbs = { alc260_acer_init_verbs },
7521                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7522                 .dac_nids = alc260_dac_nids,
7523                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7524                 .adc_nids = alc260_dual_adc_nids,
7525                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7526                 .channel_mode = alc260_modes,
7527                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7528                 .input_mux = alc260_acer_capture_sources,
7529         },
7530         [ALC260_FAVORIT100] = {
7531                 .mixers = { alc260_favorit100_mixer },
7532                 .init_verbs = { alc260_favorit100_init_verbs },
7533                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7534                 .dac_nids = alc260_dac_nids,
7535                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7536                 .adc_nids = alc260_dual_adc_nids,
7537                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7538                 .channel_mode = alc260_modes,
7539                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7540                 .input_mux = alc260_favorit100_capture_sources,
7541         },
7542         [ALC260_WILL] = {
7543                 .mixers = { alc260_will_mixer },
7544                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7545                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7546                 .dac_nids = alc260_dac_nids,
7547                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7548                 .adc_nids = alc260_adc_nids,
7549                 .dig_out_nid = ALC260_DIGOUT_NID,
7550                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7551                 .channel_mode = alc260_modes,
7552                 .input_mux = &alc260_capture_source,
7553         },
7554         [ALC260_REPLACER_672V] = {
7555                 .mixers = { alc260_replacer_672v_mixer },
7556                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7557                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7558                 .dac_nids = alc260_dac_nids,
7559                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7560                 .adc_nids = alc260_adc_nids,
7561                 .dig_out_nid = ALC260_DIGOUT_NID,
7562                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7563                 .channel_mode = alc260_modes,
7564                 .input_mux = &alc260_capture_source,
7565                 .unsol_event = alc260_replacer_672v_unsol_event,
7566                 .init_hook = alc260_replacer_672v_automute,
7567         },
7568 #ifdef CONFIG_SND_DEBUG
7569         [ALC260_TEST] = {
7570                 .mixers = { alc260_test_mixer },
7571                 .init_verbs = { alc260_test_init_verbs },
7572                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7573                 .dac_nids = alc260_test_dac_nids,
7574                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7575                 .adc_nids = alc260_test_adc_nids,
7576                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7577                 .channel_mode = alc260_modes,
7578                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7579                 .input_mux = alc260_test_capture_sources,
7580         },
7581 #endif
7582 };
7583
7584 static int patch_alc260(struct hda_codec *codec)
7585 {
7586         struct alc_spec *spec;
7587         int err, board_config;
7588
7589         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7590         if (spec == NULL)
7591                 return -ENOMEM;
7592
7593         codec->spec = spec;
7594
7595         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7596                                                   alc260_models,
7597                                                   alc260_cfg_tbl);
7598         if (board_config < 0) {
7599                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7600                            codec->chip_name);
7601                 board_config = ALC260_AUTO;
7602         }
7603
7604         if (board_config == ALC260_AUTO) {
7605                 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
7606                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
7607         }
7608
7609         if (board_config == ALC260_AUTO) {
7610                 /* automatic parse from the BIOS config */
7611                 err = alc260_parse_auto_config(codec);
7612                 if (err < 0) {
7613                         alc_free(codec);
7614                         return err;
7615                 } else if (!err) {
7616                         printk(KERN_INFO
7617                                "hda_codec: Cannot set up configuration "
7618                                "from BIOS.  Using base mode...\n");
7619                         board_config = ALC260_BASIC;
7620                 }
7621         }
7622
7623         err = snd_hda_attach_beep_device(codec, 0x1);
7624         if (err < 0) {
7625                 alc_free(codec);
7626                 return err;
7627         }
7628
7629         if (board_config != ALC260_AUTO)
7630                 setup_preset(codec, &alc260_presets[board_config]);
7631
7632         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7633         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7634         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7635
7636         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7637         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7638
7639         if (!spec->adc_nids && spec->input_mux) {
7640                 /* check whether NID 0x04 is valid */
7641                 unsigned int wcap = get_wcaps(codec, 0x04);
7642                 wcap = get_wcaps_type(wcap);
7643                 /* get type */
7644                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7645                         spec->adc_nids = alc260_adc_nids_alt;
7646                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7647                 } else {
7648                         spec->adc_nids = alc260_adc_nids;
7649                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7650                 }
7651         }
7652         set_capture_mixer(codec);
7653         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7654
7655         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7656
7657         spec->vmaster_nid = 0x08;
7658
7659         codec->patch_ops = alc_patch_ops;
7660         if (board_config == ALC260_AUTO)
7661                 spec->init_hook = alc260_auto_init;
7662         spec->shutup = alc_eapd_shutup;
7663 #ifdef CONFIG_SND_HDA_POWER_SAVE
7664         if (!spec->loopback.amplist)
7665                 spec->loopback.amplist = alc260_loopbacks;
7666 #endif
7667
7668         return 0;
7669 }
7670
7671
7672 /*
7673  * ALC882/883/885/888/889 support
7674  *
7675  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7676  * configuration.  Each pin widget can choose any input DACs and a mixer.
7677  * Each ADC is connected from a mixer of all inputs.  This makes possible
7678  * 6-channel independent captures.
7679  *
7680  * In addition, an independent DAC for the multi-playback (not used in this
7681  * driver yet).
7682  */
7683 #define ALC882_DIGOUT_NID       0x06
7684 #define ALC882_DIGIN_NID        0x0a
7685 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7686 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7687 #define ALC1200_DIGOUT_NID      0x10
7688
7689
7690 static const struct hda_channel_mode alc882_ch_modes[1] = {
7691         { 8, NULL }
7692 };
7693
7694 /* DACs */
7695 static const hda_nid_t alc882_dac_nids[4] = {
7696         /* front, rear, clfe, rear_surr */
7697         0x02, 0x03, 0x04, 0x05
7698 };
7699 #define alc883_dac_nids         alc882_dac_nids
7700
7701 /* ADCs */
7702 #define alc882_adc_nids         alc880_adc_nids
7703 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7704 #define alc883_adc_nids         alc882_adc_nids_alt
7705 static const hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7706 static const hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7707 #define alc889_adc_nids         alc880_adc_nids
7708
7709 static const hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7710 static const hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7711 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7712 static const hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7713 #define alc889_capsrc_nids      alc882_capsrc_nids
7714
7715 /* input MUX */
7716 /* FIXME: should be a matrix-type input source selection */
7717
7718 static const struct hda_input_mux alc882_capture_source = {
7719         .num_items = 4,
7720         .items = {
7721                 { "Mic", 0x0 },
7722                 { "Front Mic", 0x1 },
7723                 { "Line", 0x2 },
7724                 { "CD", 0x4 },
7725         },
7726 };
7727
7728 #define alc883_capture_source   alc882_capture_source
7729
7730 static const struct hda_input_mux alc889_capture_source = {
7731         .num_items = 3,
7732         .items = {
7733                 { "Front Mic", 0x0 },
7734                 { "Mic", 0x3 },
7735                 { "Line", 0x2 },
7736         },
7737 };
7738
7739 static const struct hda_input_mux mb5_capture_source = {
7740         .num_items = 3,
7741         .items = {
7742                 { "Mic", 0x1 },
7743                 { "Line", 0x7 },
7744                 { "CD", 0x4 },
7745         },
7746 };
7747
7748 static const struct hda_input_mux macmini3_capture_source = {
7749         .num_items = 2,
7750         .items = {
7751                 { "Line", 0x2 },
7752                 { "CD", 0x4 },
7753         },
7754 };
7755
7756 static const struct hda_input_mux alc883_3stack_6ch_intel = {
7757         .num_items = 4,
7758         .items = {
7759                 { "Mic", 0x1 },
7760                 { "Front Mic", 0x0 },
7761                 { "Line", 0x2 },
7762                 { "CD", 0x4 },
7763         },
7764 };
7765
7766 static const struct hda_input_mux alc883_lenovo_101e_capture_source = {
7767         .num_items = 2,
7768         .items = {
7769                 { "Mic", 0x1 },
7770                 { "Line", 0x2 },
7771         },
7772 };
7773
7774 static const struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7775         .num_items = 4,
7776         .items = {
7777                 { "Mic", 0x0 },
7778                 { "Internal Mic", 0x1 },
7779                 { "Line", 0x2 },
7780                 { "CD", 0x4 },
7781         },
7782 };
7783
7784 static const struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7785         .num_items = 2,
7786         .items = {
7787                 { "Mic", 0x0 },
7788                 { "Internal Mic", 0x1 },
7789         },
7790 };
7791
7792 static const struct hda_input_mux alc883_lenovo_sky_capture_source = {
7793         .num_items = 3,
7794         .items = {
7795                 { "Mic", 0x0 },
7796                 { "Front Mic", 0x1 },
7797                 { "Line", 0x4 },
7798         },
7799 };
7800
7801 static const struct hda_input_mux alc883_asus_eee1601_capture_source = {
7802         .num_items = 2,
7803         .items = {
7804                 { "Mic", 0x0 },
7805                 { "Line", 0x2 },
7806         },
7807 };
7808
7809 static const struct hda_input_mux alc889A_mb31_capture_source = {
7810         .num_items = 2,
7811         .items = {
7812                 { "Mic", 0x0 },
7813                 /* Front Mic (0x01) unused */
7814                 { "Line", 0x2 },
7815                 /* Line 2 (0x03) unused */
7816                 /* CD (0x04) unused? */
7817         },
7818 };
7819
7820 static const struct hda_input_mux alc889A_imac91_capture_source = {
7821         .num_items = 2,
7822         .items = {
7823                 { "Mic", 0x01 },
7824                 { "Line", 0x2 }, /* Not sure! */
7825         },
7826 };
7827
7828 /*
7829  * 2ch mode
7830  */
7831 static const struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7832         { 2, NULL }
7833 };
7834
7835 /*
7836  * 2ch mode
7837  */
7838 static const struct hda_verb alc882_3ST_ch2_init[] = {
7839         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7840         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7841         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7842         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7843         { } /* end */
7844 };
7845
7846 /*
7847  * 4ch mode
7848  */
7849 static const struct hda_verb alc882_3ST_ch4_init[] = {
7850         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7851         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7852         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7853         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7854         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7855         { } /* end */
7856 };
7857
7858 /*
7859  * 6ch mode
7860  */
7861 static const struct hda_verb alc882_3ST_ch6_init[] = {
7862         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7863         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7864         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7865         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7866         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7867         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7868         { } /* end */
7869 };
7870
7871 static const struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7872         { 2, alc882_3ST_ch2_init },
7873         { 4, alc882_3ST_ch4_init },
7874         { 6, alc882_3ST_ch6_init },
7875 };
7876
7877 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7878
7879 /*
7880  * 2ch mode
7881  */
7882 static const struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7883         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7884         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7885         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7886         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7887         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7888         { } /* end */
7889 };
7890
7891 /*
7892  * 4ch mode
7893  */
7894 static const struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7895         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7896         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7897         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7898         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7899         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7900         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7901         { } /* end */
7902 };
7903
7904 /*
7905  * 6ch mode
7906  */
7907 static const struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7908         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7909         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7910         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7911         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7912         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7913         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7914         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7915         { } /* end */
7916 };
7917
7918 static const struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7919         { 2, alc883_3ST_ch2_clevo_init },
7920         { 4, alc883_3ST_ch4_clevo_init },
7921         { 6, alc883_3ST_ch6_clevo_init },
7922 };
7923
7924
7925 /*
7926  * 6ch mode
7927  */
7928 static const struct hda_verb alc882_sixstack_ch6_init[] = {
7929         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7930         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7931         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7932         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7933         { } /* end */
7934 };
7935
7936 /*
7937  * 8ch mode
7938  */
7939 static const struct hda_verb alc882_sixstack_ch8_init[] = {
7940         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7941         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7942         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7943         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7944         { } /* end */
7945 };
7946
7947 static const struct hda_channel_mode alc882_sixstack_modes[2] = {
7948         { 6, alc882_sixstack_ch6_init },
7949         { 8, alc882_sixstack_ch8_init },
7950 };
7951
7952
7953 /* Macbook Air 2,1 */
7954
7955 static const struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7956       { 2, NULL },
7957 };
7958
7959 /*
7960  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7961  */
7962
7963 /*
7964  * 2ch mode
7965  */
7966 static const struct hda_verb alc885_mbp_ch2_init[] = {
7967         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7968         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7969         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7970         { } /* end */
7971 };
7972
7973 /*
7974  * 4ch mode
7975  */
7976 static const struct hda_verb alc885_mbp_ch4_init[] = {
7977         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7978         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7979         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7980         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7981         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7982         { } /* end */
7983 };
7984
7985 static const struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7986         { 2, alc885_mbp_ch2_init },
7987         { 4, alc885_mbp_ch4_init },
7988 };
7989
7990 /*
7991  * 2ch
7992  * Speakers/Woofer/HP = Front
7993  * LineIn = Input
7994  */
7995 static const struct hda_verb alc885_mb5_ch2_init[] = {
7996         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7997         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7998         { } /* end */
7999 };
8000
8001 /*
8002  * 6ch mode
8003  * Speakers/HP = Front
8004  * Woofer = LFE
8005  * LineIn = Surround
8006  */
8007 static const struct hda_verb alc885_mb5_ch6_init[] = {
8008         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8009         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8010         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8011         { } /* end */
8012 };
8013
8014 static const struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
8015         { 2, alc885_mb5_ch2_init },
8016         { 6, alc885_mb5_ch6_init },
8017 };
8018
8019 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
8020
8021 /*
8022  * 2ch mode
8023  */
8024 static const struct hda_verb alc883_4ST_ch2_init[] = {
8025         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8026         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8027         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8028         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8029         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8030         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8031         { } /* end */
8032 };
8033
8034 /*
8035  * 4ch mode
8036  */
8037 static const struct hda_verb alc883_4ST_ch4_init[] = {
8038         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8039         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8040         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8041         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8042         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8043         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8044         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8045         { } /* end */
8046 };
8047
8048 /*
8049  * 6ch mode
8050  */
8051 static const struct hda_verb alc883_4ST_ch6_init[] = {
8052         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8053         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8054         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8055         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8056         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8057         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8058         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8059         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8060         { } /* end */
8061 };
8062
8063 /*
8064  * 8ch mode
8065  */
8066 static const struct hda_verb alc883_4ST_ch8_init[] = {
8067         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8068         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8069         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8070         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8071         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8072         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8073         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8074         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8075         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8076         { } /* end */
8077 };
8078
8079 static const struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
8080         { 2, alc883_4ST_ch2_init },
8081         { 4, alc883_4ST_ch4_init },
8082         { 6, alc883_4ST_ch6_init },
8083         { 8, alc883_4ST_ch8_init },
8084 };
8085
8086
8087 /*
8088  * 2ch mode
8089  */
8090 static const struct hda_verb alc883_3ST_ch2_intel_init[] = {
8091         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8092         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8093         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8094         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8095         { } /* end */
8096 };
8097
8098 /*
8099  * 4ch mode
8100  */
8101 static const struct hda_verb alc883_3ST_ch4_intel_init[] = {
8102         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8103         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8104         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8105         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8106         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8107         { } /* end */
8108 };
8109
8110 /*
8111  * 6ch mode
8112  */
8113 static const struct hda_verb alc883_3ST_ch6_intel_init[] = {
8114         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8115         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8116         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
8117         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8118         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8119         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8120         { } /* end */
8121 };
8122
8123 static const struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
8124         { 2, alc883_3ST_ch2_intel_init },
8125         { 4, alc883_3ST_ch4_intel_init },
8126         { 6, alc883_3ST_ch6_intel_init },
8127 };
8128
8129 /*
8130  * 2ch mode
8131  */
8132 static const struct hda_verb alc889_ch2_intel_init[] = {
8133         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8134         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
8135         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
8136         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
8137         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8138         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8139         { } /* end */
8140 };
8141
8142 /*
8143  * 6ch mode
8144  */
8145 static const struct hda_verb alc889_ch6_intel_init[] = {
8146         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8147         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
8148         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
8149         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8150         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8151         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8152         { } /* end */
8153 };
8154
8155 /*
8156  * 8ch mode
8157  */
8158 static const struct hda_verb alc889_ch8_intel_init[] = {
8159         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8160         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
8161         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
8162         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8163         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
8164         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8165         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8166         { } /* end */
8167 };
8168
8169 static const struct hda_channel_mode alc889_8ch_intel_modes[3] = {
8170         { 2, alc889_ch2_intel_init },
8171         { 6, alc889_ch6_intel_init },
8172         { 8, alc889_ch8_intel_init },
8173 };
8174
8175 /*
8176  * 6ch mode
8177  */
8178 static const struct hda_verb alc883_sixstack_ch6_init[] = {
8179         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
8180         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8181         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8182         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8183         { } /* end */
8184 };
8185
8186 /*
8187  * 8ch mode
8188  */
8189 static const struct hda_verb alc883_sixstack_ch8_init[] = {
8190         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8191         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8192         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8193         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8194         { } /* end */
8195 };
8196
8197 static const struct hda_channel_mode alc883_sixstack_modes[2] = {
8198         { 6, alc883_sixstack_ch6_init },
8199         { 8, alc883_sixstack_ch8_init },
8200 };
8201
8202
8203 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
8204  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
8205  */
8206 static const struct snd_kcontrol_new alc882_base_mixer[] = {
8207         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8208         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8209         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8210         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8211         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8212         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8213         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8214         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8215         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8216         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8217         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8218         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8219         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8220         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8221         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8222         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8223         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8224         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8225         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8226         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8227         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8228         { } /* end */
8229 };
8230
8231 /* Macbook Air 2,1 same control for HP and internal Speaker */
8232
8233 static const struct snd_kcontrol_new alc885_mba21_mixer[] = {
8234       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8235       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
8236      { }
8237 };
8238
8239
8240 static const struct snd_kcontrol_new alc885_mbp3_mixer[] = {
8241         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8242         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8243         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8244         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
8245         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8246         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8247         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8248         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8249         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8250         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
8251         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
8252         { } /* end */
8253 };
8254
8255 static const struct snd_kcontrol_new alc885_mb5_mixer[] = {
8256         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8257         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8258         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8259         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8260         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8261         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8262         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8263         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8264         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8265         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8266         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8267         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8268         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8269         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT),
8270         { } /* end */
8271 };
8272
8273 static const struct snd_kcontrol_new alc885_macmini3_mixer[] = {
8274         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8275         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8276         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8277         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8278         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8279         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8280         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8281         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8282         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8283         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8284         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8285         { } /* end */
8286 };
8287
8288 static const struct snd_kcontrol_new alc885_imac91_mixer[] = {
8289         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8290         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8291         { } /* end */
8292 };
8293
8294
8295 static const struct snd_kcontrol_new alc882_w2jc_mixer[] = {
8296         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8297         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8298         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8299         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8300         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8301         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8302         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8303         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8304         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8305         { } /* end */
8306 };
8307
8308 static const struct snd_kcontrol_new alc882_targa_mixer[] = {
8309         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8310         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8311         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8312         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8313         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8314         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8315         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8316         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8317         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8318         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8319         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8320         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8321         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8322         { } /* end */
8323 };
8324
8325 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8326  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8327  */
8328 static const struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8329         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8330         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8331         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8332         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8333         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8334         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8335         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8336         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8337         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8338         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8339         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8340         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8341         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8342         { } /* end */
8343 };
8344
8345 static const struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8346         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8347         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8348         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8349         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8350         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8351         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8352         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8353         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8354         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8355         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8356         { } /* end */
8357 };
8358
8359 static const struct snd_kcontrol_new alc882_chmode_mixer[] = {
8360         {
8361                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8362                 .name = "Channel Mode",
8363                 .info = alc_ch_mode_info,
8364                 .get = alc_ch_mode_get,
8365                 .put = alc_ch_mode_put,
8366         },
8367         { } /* end */
8368 };
8369
8370 static const struct hda_verb alc882_base_init_verbs[] = {
8371         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8372         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8373         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8374         /* Rear mixer */
8375         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8376         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8377         /* CLFE mixer */
8378         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8379         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8380         /* Side mixer */
8381         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8382         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8383
8384         /* Front Pin: output 0 (0x0c) */
8385         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8386         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8387         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8388         /* Rear Pin: output 1 (0x0d) */
8389         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8390         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8391         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8392         /* CLFE Pin: output 2 (0x0e) */
8393         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8394         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8395         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8396         /* Side Pin: output 3 (0x0f) */
8397         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8398         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8399         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8400         /* Mic (rear) pin: input vref at 80% */
8401         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8402         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8403         /* Front Mic pin: input vref at 80% */
8404         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8405         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8406         /* Line In pin: input */
8407         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8408         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8409         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8410         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8411         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8412         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8413         /* CD pin widget for input */
8414         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8415
8416         /* FIXME: use matrix-type input source selection */
8417         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8418         /* Input mixer2 */
8419         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8420         /* Input mixer3 */
8421         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8422         /* ADC2: mute amp left and right */
8423         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8424         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8425         /* ADC3: mute amp left and right */
8426         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8427         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8428
8429         { }
8430 };
8431
8432 static const struct hda_verb alc882_adc1_init_verbs[] = {
8433         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8434         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8435         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8436         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8437         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8438         /* ADC1: mute amp left and right */
8439         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8440         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8441         { }
8442 };
8443
8444 static const struct hda_verb alc882_eapd_verbs[] = {
8445         /* change to EAPD mode */
8446         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8447         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8448         { }
8449 };
8450
8451 static const struct hda_verb alc889_eapd_verbs[] = {
8452         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8453         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8454         { }
8455 };
8456
8457 static const struct hda_verb alc_hp15_unsol_verbs[] = {
8458         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8459         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8460         {}
8461 };
8462
8463 static const struct hda_verb alc885_init_verbs[] = {
8464         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8465         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8466         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8467         /* Rear mixer */
8468         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8469         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8470         /* CLFE mixer */
8471         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8472         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8473         /* Side mixer */
8474         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8475         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8476
8477         /* Front HP Pin: output 0 (0x0c) */
8478         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8479         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8480         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8481         /* Front Pin: output 0 (0x0c) */
8482         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8483         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8484         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8485         /* Rear Pin: output 1 (0x0d) */
8486         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8487         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8488         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8489         /* CLFE Pin: output 2 (0x0e) */
8490         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8491         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8492         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8493         /* Side Pin: output 3 (0x0f) */
8494         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8495         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8496         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8497         /* Mic (rear) pin: input vref at 80% */
8498         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8499         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8500         /* Front Mic pin: input vref at 80% */
8501         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8502         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8503         /* Line In pin: input */
8504         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8505         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8506
8507         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8508         /* Input mixer1 */
8509         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8510         /* Input mixer2 */
8511         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8512         /* Input mixer3 */
8513         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8514         /* ADC2: mute amp left and right */
8515         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8516         /* ADC3: mute amp left and right */
8517         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8518
8519         { }
8520 };
8521
8522 static const struct hda_verb alc885_init_input_verbs[] = {
8523         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8524         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8525         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8526         { }
8527 };
8528
8529
8530 /* Unmute Selector 24h and set the default input to front mic */
8531 static const struct hda_verb alc889_init_input_verbs[] = {
8532         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8533         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8534         { }
8535 };
8536
8537
8538 #define alc883_init_verbs       alc882_base_init_verbs
8539
8540 /* Mac Pro test */
8541 static const struct snd_kcontrol_new alc882_macpro_mixer[] = {
8542         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8543         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8544         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8545         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8546         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8547         /* FIXME: this looks suspicious...
8548         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8549         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8550         */
8551         { } /* end */
8552 };
8553
8554 static const struct hda_verb alc882_macpro_init_verbs[] = {
8555         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8556         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8557         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8558         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8559         /* Front Pin: output 0 (0x0c) */
8560         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8561         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8562         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8563         /* Front Mic pin: input vref at 80% */
8564         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8565         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8566         /* Speaker:  output */
8567         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8568         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8569         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8570         /* Headphone output (output 0 - 0x0c) */
8571         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8572         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8573         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8574
8575         /* FIXME: use matrix-type input source selection */
8576         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8577         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8578         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8579         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8580         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8581         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8582         /* Input mixer2 */
8583         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8584         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8585         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8586         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8587         /* Input mixer3 */
8588         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8589         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8590         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8591         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8592         /* ADC1: mute amp left and right */
8593         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8594         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8595         /* ADC2: mute amp left and right */
8596         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8597         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8598         /* ADC3: mute amp left and right */
8599         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8600         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8601
8602         { }
8603 };
8604
8605 /* Macbook 5,1 */
8606 static const struct hda_verb alc885_mb5_init_verbs[] = {
8607         /* DACs */
8608         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8609         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8610         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8611         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8612         /* Front mixer */
8613         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8614         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8615         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8616         /* Surround mixer */
8617         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8618         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8619         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8620         /* LFE mixer */
8621         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8622         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8623         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8624         /* HP mixer */
8625         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8626         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8627         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8628         /* Front Pin (0x0c) */
8629         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8630         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8631         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8632         /* LFE Pin (0x0e) */
8633         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8634         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8635         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8636         /* HP Pin (0x0f) */
8637         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8638         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8639         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8640         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8641         /* Front Mic pin: input vref at 80% */
8642         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8643         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8644         /* Line In pin */
8645         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8646         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8647
8648         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8649         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8650         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8651         { }
8652 };
8653
8654 /* Macmini 3,1 */
8655 static const struct hda_verb alc885_macmini3_init_verbs[] = {
8656         /* DACs */
8657         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8658         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8659         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8660         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8661         /* Front mixer */
8662         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8663         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8664         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8665         /* Surround mixer */
8666         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8667         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8668         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8669         /* LFE mixer */
8670         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8671         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8672         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8673         /* HP mixer */
8674         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8675         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8676         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8677         /* Front Pin (0x0c) */
8678         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8679         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8680         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8681         /* LFE Pin (0x0e) */
8682         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8683         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8684         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8685         /* HP Pin (0x0f) */
8686         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8687         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8688         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8689         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8690         /* Line In pin */
8691         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8692         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8693
8694         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8695         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8696         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8697         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8698         { }
8699 };
8700
8701
8702 static const struct hda_verb alc885_mba21_init_verbs[] = {
8703         /*Internal and HP Speaker Mixer*/
8704         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8705         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8706         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8707         /*Internal Speaker Pin (0x0c)*/
8708         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8709         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8710         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8711         /* HP Pin: output 0 (0x0e) */
8712         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8713         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8714         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8715         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8716         /* Line in (is hp when jack connected)*/
8717         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8718         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8719
8720         { }
8721  };
8722
8723
8724 /* Macbook Pro rev3 */
8725 static const struct hda_verb alc885_mbp3_init_verbs[] = {
8726         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8727         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8728         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8729         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8730         /* Rear mixer */
8731         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8732         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8733         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8734         /* HP mixer */
8735         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8736         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8737         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8738         /* Front Pin: output 0 (0x0c) */
8739         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8740         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8741         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8742         /* HP Pin: output 0 (0x0e) */
8743         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8744         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8745         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8746         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8747         /* Mic (rear) pin: input vref at 80% */
8748         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8749         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8750         /* Front Mic pin: input vref at 80% */
8751         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8752         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8753         /* Line In pin: use output 1 when in LineOut mode */
8754         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8755         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8756         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8757
8758         /* FIXME: use matrix-type input source selection */
8759         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8760         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8761         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8762         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8763         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8764         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8765         /* Input mixer2 */
8766         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8767         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8768         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8769         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8770         /* Input mixer3 */
8771         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8772         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8773         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8774         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8775         /* ADC1: mute amp left and right */
8776         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8777         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8778         /* ADC2: mute amp left and right */
8779         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8780         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8781         /* ADC3: mute amp left and right */
8782         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8783         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8784
8785         { }
8786 };
8787
8788 /* iMac 9,1 */
8789 static const struct hda_verb alc885_imac91_init_verbs[] = {
8790         /* Internal Speaker Pin (0x0c) */
8791         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8792         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8793         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8794         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8795         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8796         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8797         /* HP Pin: Rear */
8798         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8799         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8800         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8801         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8802         /* Line in Rear */
8803         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8804         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8805         /* Front Mic pin: input vref at 80% */
8806         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8807         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8808         /* Rear mixer */
8809         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8810         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8811         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8812         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8813         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8814         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8815         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8816         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8817         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8818         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8819         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8820         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8821         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8822         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8823         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8824         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8825         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8826         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8827         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8828         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8829         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8830         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8831         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8832         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8833         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8834         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8835         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8836         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8837         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8838         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8839         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8840         { }
8841 };
8842
8843 /* iMac 24 mixer. */
8844 static const struct snd_kcontrol_new alc885_imac24_mixer[] = {
8845         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8846         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8847         { } /* end */
8848 };
8849
8850 /* iMac 24 init verbs. */
8851 static const struct hda_verb alc885_imac24_init_verbs[] = {
8852         /* Internal speakers: output 0 (0x0c) */
8853         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8854         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8855         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8856         /* Internal speakers: output 0 (0x0c) */
8857         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8858         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8859         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8860         /* Headphone: output 0 (0x0c) */
8861         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8862         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8863         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8864         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8865         /* Front Mic: input vref at 80% */
8866         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8867         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8868         { }
8869 };
8870
8871 /* Toggle speaker-output according to the hp-jack state */
8872 static void alc885_imac24_setup(struct hda_codec *codec)
8873 {
8874         struct alc_spec *spec = codec->spec;
8875
8876         spec->autocfg.hp_pins[0] = 0x14;
8877         spec->autocfg.speaker_pins[0] = 0x18;
8878         spec->autocfg.speaker_pins[1] = 0x1a;
8879         spec->automute = 1;
8880         spec->automute_mode = ALC_AUTOMUTE_AMP;
8881 }
8882
8883 #define alc885_mb5_setup        alc885_imac24_setup
8884 #define alc885_macmini3_setup   alc885_imac24_setup
8885
8886 /* Macbook Air 2,1 */
8887 static void alc885_mba21_setup(struct hda_codec *codec)
8888 {
8889        struct alc_spec *spec = codec->spec;
8890
8891        spec->autocfg.hp_pins[0] = 0x14;
8892        spec->autocfg.speaker_pins[0] = 0x18;
8893         spec->automute = 1;
8894         spec->automute_mode = ALC_AUTOMUTE_AMP;
8895 }
8896
8897
8898
8899 static void alc885_mbp3_setup(struct hda_codec *codec)
8900 {
8901         struct alc_spec *spec = codec->spec;
8902
8903         spec->autocfg.hp_pins[0] = 0x15;
8904         spec->autocfg.speaker_pins[0] = 0x14;
8905         spec->automute = 1;
8906         spec->automute_mode = ALC_AUTOMUTE_AMP;
8907 }
8908
8909 static void alc885_imac91_setup(struct hda_codec *codec)
8910 {
8911         struct alc_spec *spec = codec->spec;
8912
8913         spec->autocfg.hp_pins[0] = 0x14;
8914         spec->autocfg.speaker_pins[0] = 0x18;
8915         spec->autocfg.speaker_pins[1] = 0x1a;
8916         spec->automute = 1;
8917         spec->automute_mode = ALC_AUTOMUTE_AMP;
8918 }
8919
8920 static const struct hda_verb alc882_targa_verbs[] = {
8921         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8922         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8923
8924         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8925         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8926
8927         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8928         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8929         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8930
8931         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8932         { } /* end */
8933 };
8934
8935 /* toggle speaker-output according to the hp-jack state */
8936 static void alc882_targa_automute(struct hda_codec *codec)
8937 {
8938         struct alc_spec *spec = codec->spec;
8939         alc_hp_automute(codec);
8940         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8941                                   spec->jack_present ? 1 : 3);
8942 }
8943
8944 static void alc882_targa_setup(struct hda_codec *codec)
8945 {
8946         struct alc_spec *spec = codec->spec;
8947
8948         spec->autocfg.hp_pins[0] = 0x14;
8949         spec->autocfg.speaker_pins[0] = 0x1b;
8950         spec->automute = 1;
8951         spec->automute_mode = ALC_AUTOMUTE_AMP;
8952 }
8953
8954 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8955 {
8956         if ((res >> 26) == ALC880_HP_EVENT)
8957                 alc882_targa_automute(codec);
8958 }
8959
8960 static const struct hda_verb alc882_asus_a7j_verbs[] = {
8961         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8962         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8963
8964         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8965         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8966         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8967
8968         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8969         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8970         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8971
8972         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8973         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8974         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8975         { } /* end */
8976 };
8977
8978 static const struct hda_verb alc882_asus_a7m_verbs[] = {
8979         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8980         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8981
8982         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8983         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8984         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8985
8986         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8987         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8988         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8989
8990         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8991         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8992         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8993         { } /* end */
8994 };
8995
8996 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8997 {
8998         unsigned int gpiostate, gpiomask, gpiodir;
8999
9000         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
9001                                        AC_VERB_GET_GPIO_DATA, 0);
9002
9003         if (!muted)
9004                 gpiostate |= (1 << pin);
9005         else
9006                 gpiostate &= ~(1 << pin);
9007
9008         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
9009                                       AC_VERB_GET_GPIO_MASK, 0);
9010         gpiomask |= (1 << pin);
9011
9012         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
9013                                      AC_VERB_GET_GPIO_DIRECTION, 0);
9014         gpiodir |= (1 << pin);
9015
9016
9017         snd_hda_codec_write(codec, codec->afg, 0,
9018                             AC_VERB_SET_GPIO_MASK, gpiomask);
9019         snd_hda_codec_write(codec, codec->afg, 0,
9020                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
9021
9022         msleep(1);
9023
9024         snd_hda_codec_write(codec, codec->afg, 0,
9025                             AC_VERB_SET_GPIO_DATA, gpiostate);
9026 }
9027
9028 /* set up GPIO at initialization */
9029 static void alc885_macpro_init_hook(struct hda_codec *codec)
9030 {
9031         alc882_gpio_mute(codec, 0, 0);
9032         alc882_gpio_mute(codec, 1, 0);
9033 }
9034
9035 /* set up GPIO and update auto-muting at initialization */
9036 static void alc885_imac24_init_hook(struct hda_codec *codec)
9037 {
9038         alc885_macpro_init_hook(codec);
9039         alc_hp_automute(codec);
9040 }
9041
9042 /*
9043  * generic initialization of ADC, input mixers and output mixers
9044  */
9045 static const struct hda_verb alc883_auto_init_verbs[] = {
9046         /*
9047          * Unmute ADC0-2 and set the default input to mic-in
9048          */
9049         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9050         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9051         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9052         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9053
9054         /*
9055          * Set up output mixers (0x0c - 0x0f)
9056          */
9057         /* set vol=0 to output mixers */
9058         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9059         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9060         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9061         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9062         /* set up input amps for analog loopback */
9063         /* Amp Indices: DAC = 0, mixer = 1 */
9064         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9065         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9066         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9067         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9068         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9069         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9070         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9071         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9072         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9073         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9074
9075         /* FIXME: use matrix-type input source selection */
9076         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9077         /* Input mixer2 */
9078         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9079         /* Input mixer3 */
9080         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9081         { }
9082 };
9083
9084 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
9085 static const struct hda_verb alc889A_mb31_ch2_init[] = {
9086         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
9087         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9088         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
9089         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
9090         { } /* end */
9091 };
9092
9093 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
9094 static const struct hda_verb alc889A_mb31_ch4_init[] = {
9095         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
9096         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9097         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
9098         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
9099         { } /* end */
9100 };
9101
9102 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
9103 static const struct hda_verb alc889A_mb31_ch5_init[] = {
9104         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
9105         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9106         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
9107         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
9108         { } /* end */
9109 };
9110
9111 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
9112 static const struct hda_verb alc889A_mb31_ch6_init[] = {
9113         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
9114         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
9115         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
9116         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
9117         { } /* end */
9118 };
9119
9120 static const struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
9121         { 2, alc889A_mb31_ch2_init },
9122         { 4, alc889A_mb31_ch4_init },
9123         { 5, alc889A_mb31_ch5_init },
9124         { 6, alc889A_mb31_ch6_init },
9125 };
9126
9127 static const struct hda_verb alc883_medion_eapd_verbs[] = {
9128         /* eanable EAPD on medion laptop */
9129         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9130         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
9131         { }
9132 };
9133
9134 #define alc883_base_mixer       alc882_base_mixer
9135
9136 static const struct snd_kcontrol_new alc883_mitac_mixer[] = {
9137         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9138         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9139         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9140         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9141         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9142         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9143         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9144         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9145         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9146         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9147         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9148         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9149         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9150         { } /* end */
9151 };
9152
9153 static const struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
9154         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9155         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
9156         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9157         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9158         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9159         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9160         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9161         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9162         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9163         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9164         { } /* end */
9165 };
9166
9167 static const struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
9168         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9169         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
9170         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9171         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9172         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9173         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9174         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9175         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9176         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9177         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9178         { } /* end */
9179 };
9180
9181 static const struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
9182         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9183         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9184         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9185         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9186         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9187         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9188         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9189         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9190         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9191         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9192         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9193         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9194         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9195         { } /* end */
9196 };
9197
9198 static const struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
9199         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9200         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9201         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9202         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9203         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9204         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9205         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9206         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9207         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9208         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9209         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9210         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9211         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9212         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9213         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9214         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9215         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9216         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9217         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9218         { } /* end */
9219 };
9220
9221 static const struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
9222         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9223         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9224         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9225         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9226         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
9227                               HDA_OUTPUT),
9228         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9229         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9230         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9231         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9232         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9233         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9234         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9235         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9236         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9237         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9238         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9239         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9240         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9241         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9242         { } /* end */
9243 };
9244
9245 static const struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
9246         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9247         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9248         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9249         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9250         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
9251                               HDA_OUTPUT),
9252         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9253         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9254         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9255         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9256         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
9257         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9258         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9259         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9260         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
9261         HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT),
9262         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
9263         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9264         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9265         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9266         { } /* end */
9267 };
9268
9269 static const struct snd_kcontrol_new alc883_fivestack_mixer[] = {
9270         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9271         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9272         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9273         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9274         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9275         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9276         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9277         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9278         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9279         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9280         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9281         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9282         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9283         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9284         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9285         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9286         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9287         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9288         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9289         { } /* end */
9290 };
9291
9292 static const struct snd_kcontrol_new alc883_targa_mixer[] = {
9293         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9294         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9295         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9296         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9297         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9298         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9299         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9300         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9301         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9302         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9303         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9304         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9305         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9306         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9307         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9308         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9309         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9310         { } /* end */
9311 };
9312
9313 static const struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
9314         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9315         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9316         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9317         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9318         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9319         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9320         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9321         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9322         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9323         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9324         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9325         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9326         { } /* end */
9327 };
9328
9329 static const struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
9330         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9331         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9332         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9333         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9334         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9335         { } /* end */
9336 };
9337
9338 static const struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9339         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9340         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9341         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9342         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9343         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9344         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9345         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9346         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9347         { } /* end */
9348 };
9349
9350 static const struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9351         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9352         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9353         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9354         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9355         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9356         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9357         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9358         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9359         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9360         { } /* end */
9361 };
9362
9363 static const struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9364         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9365         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9366         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9367         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9368         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9369         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9370         { } /* end */
9371 };
9372
9373 static const struct hda_verb alc883_medion_wim2160_verbs[] = {
9374         /* Unmute front mixer */
9375         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9376         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9377
9378         /* Set speaker pin to front mixer */
9379         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9380
9381         /* Init headphone pin */
9382         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9383         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9384         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9385         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9386
9387         { } /* end */
9388 };
9389
9390 /* toggle speaker-output according to the hp-jack state */
9391 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9392 {
9393         struct alc_spec *spec = codec->spec;
9394
9395         spec->autocfg.hp_pins[0] = 0x1a;
9396         spec->autocfg.speaker_pins[0] = 0x15;
9397         spec->automute = 1;
9398         spec->automute_mode = ALC_AUTOMUTE_AMP;
9399 }
9400
9401 static const struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9402         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9403         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9404         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9405         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9406         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9407         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9408         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9409         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9410         { } /* end */
9411 };
9412
9413 static const struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9414         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9415         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9416         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9417         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9418         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9419         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9420         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9421         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9422         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9423         { } /* end */
9424 };
9425
9426 static const struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9427         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9428         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9429         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9430         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9431         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9432                                                 0x0d, 1, 0x0, HDA_OUTPUT),
9433         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9434         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9435         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9436         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9437         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9438         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9439         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9440         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9441         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9442         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9443         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9444         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9445         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9446         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9447         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9448         { } /* end */
9449 };
9450
9451 static const struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9452         /* Output mixers */
9453         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9454         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9455         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9456         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9457         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9458                 HDA_OUTPUT),
9459         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9460         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9461         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9462         /* Output switches */
9463         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9464         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9465         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9466         /* Boost mixers */
9467         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
9468         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
9469         /* Input mixers */
9470         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9471         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9472         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9473         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9474         { } /* end */
9475 };
9476
9477 static const struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9478         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9479         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9480         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9481         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9482         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9483         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9484         { } /* end */
9485 };
9486
9487 static const struct hda_bind_ctls alc883_bind_cap_vol = {
9488         .ops = &snd_hda_bind_vol,
9489         .values = {
9490                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9491                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9492                 0
9493         },
9494 };
9495
9496 static const struct hda_bind_ctls alc883_bind_cap_switch = {
9497         .ops = &snd_hda_bind_sw,
9498         .values = {
9499                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9500                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9501                 0
9502         },
9503 };
9504
9505 static const struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9506         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9507         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9508         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9509         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9510         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9511         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9512         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9513         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9514         { } /* end */
9515 };
9516
9517 static const struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9518         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9519         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9520         {
9521                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9522                 /* .name = "Capture Source", */
9523                 .name = "Input Source",
9524                 .count = 1,
9525                 .info = alc_mux_enum_info,
9526                 .get = alc_mux_enum_get,
9527                 .put = alc_mux_enum_put,
9528         },
9529         { } /* end */
9530 };
9531
9532 static const struct snd_kcontrol_new alc883_chmode_mixer[] = {
9533         {
9534                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9535                 .name = "Channel Mode",
9536                 .info = alc_ch_mode_info,
9537                 .get = alc_ch_mode_get,
9538                 .put = alc_ch_mode_put,
9539         },
9540         { } /* end */
9541 };
9542
9543 /* toggle speaker-output according to the hp-jack state */
9544 static void alc883_mitac_setup(struct hda_codec *codec)
9545 {
9546         struct alc_spec *spec = codec->spec;
9547
9548         spec->autocfg.hp_pins[0] = 0x15;
9549         spec->autocfg.speaker_pins[0] = 0x14;
9550         spec->autocfg.speaker_pins[1] = 0x17;
9551         spec->automute = 1;
9552         spec->automute_mode = ALC_AUTOMUTE_AMP;
9553 }
9554
9555 static const struct hda_verb alc883_mitac_verbs[] = {
9556         /* HP */
9557         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9558         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9559         /* Subwoofer */
9560         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9561         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9562
9563         /* enable unsolicited event */
9564         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9565         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9566
9567         { } /* end */
9568 };
9569
9570 static const struct hda_verb alc883_clevo_m540r_verbs[] = {
9571         /* HP */
9572         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9573         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9574         /* Int speaker */
9575         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9576
9577         /* enable unsolicited event */
9578         /*
9579         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9580         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9581         */
9582
9583         { } /* end */
9584 };
9585
9586 static const struct hda_verb alc883_clevo_m720_verbs[] = {
9587         /* HP */
9588         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9590         /* Int speaker */
9591         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9592         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9593
9594         /* enable unsolicited event */
9595         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9596         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9597
9598         { } /* end */
9599 };
9600
9601 static const struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9602         /* HP */
9603         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9604         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9605         /* Subwoofer */
9606         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9607         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9608
9609         /* enable unsolicited event */
9610         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9611
9612         { } /* end */
9613 };
9614
9615 static const struct hda_verb alc883_targa_verbs[] = {
9616         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9617         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9618
9619         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9620         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9621
9622 /* Connect Line-Out side jack (SPDIF) to Side */
9623         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9624         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9625         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9626 /* Connect Mic jack to CLFE */
9627         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9628         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9629         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9630 /* Connect Line-in jack to Surround */
9631         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9632         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9633         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9634 /* Connect HP out jack to Front */
9635         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9636         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9637         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9638
9639         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9640
9641         { } /* end */
9642 };
9643
9644 static const struct hda_verb alc883_lenovo_101e_verbs[] = {
9645         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9646         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9647         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9648         { } /* end */
9649 };
9650
9651 static const struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9652         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9653         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9654         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9655         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9656         { } /* end */
9657 };
9658
9659 static const struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9660         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9661         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9662         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9663         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9664         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9665         { } /* end */
9666 };
9667
9668 static const struct hda_verb alc883_haier_w66_verbs[] = {
9669         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9670         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9671
9672         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9673
9674         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9675         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9676         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9677         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9678         { } /* end */
9679 };
9680
9681 static const struct hda_verb alc888_lenovo_sky_verbs[] = {
9682         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9683         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9684         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9685         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9686         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9687         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9688         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9689         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9690         { } /* end */
9691 };
9692
9693 static const struct hda_verb alc888_6st_dell_verbs[] = {
9694         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9695         { }
9696 };
9697
9698 static const struct hda_verb alc883_vaiott_verbs[] = {
9699         /* HP */
9700         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9701         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9702
9703         /* enable unsolicited event */
9704         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9705
9706         { } /* end */
9707 };
9708
9709 static void alc888_3st_hp_setup(struct hda_codec *codec)
9710 {
9711         struct alc_spec *spec = codec->spec;
9712
9713         spec->autocfg.hp_pins[0] = 0x1b;
9714         spec->autocfg.speaker_pins[0] = 0x14;
9715         spec->autocfg.speaker_pins[1] = 0x16;
9716         spec->autocfg.speaker_pins[2] = 0x18;
9717         spec->automute = 1;
9718         spec->automute_mode = ALC_AUTOMUTE_AMP;
9719 }
9720
9721 static const struct hda_verb alc888_3st_hp_verbs[] = {
9722         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9723         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9724         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9725         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9726         { } /* end */
9727 };
9728
9729 /*
9730  * 2ch mode
9731  */
9732 static const struct hda_verb alc888_3st_hp_2ch_init[] = {
9733         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9734         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9735         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9736         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9737         { } /* end */
9738 };
9739
9740 /*
9741  * 4ch mode
9742  */
9743 static const struct hda_verb alc888_3st_hp_4ch_init[] = {
9744         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9745         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9746         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9747         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9748         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9749         { } /* end */
9750 };
9751
9752 /*
9753  * 6ch mode
9754  */
9755 static const struct hda_verb alc888_3st_hp_6ch_init[] = {
9756         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9757         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9758         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9759         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9760         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9761         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9762         { } /* end */
9763 };
9764
9765 static const struct hda_channel_mode alc888_3st_hp_modes[3] = {
9766         { 2, alc888_3st_hp_2ch_init },
9767         { 4, alc888_3st_hp_4ch_init },
9768         { 6, alc888_3st_hp_6ch_init },
9769 };
9770
9771 static void alc888_lenovo_ms7195_setup(struct hda_codec *codec)
9772 {
9773         struct alc_spec *spec = codec->spec;
9774
9775         spec->autocfg.hp_pins[0] = 0x1b;
9776         spec->autocfg.line_out_pins[0] = 0x14;
9777         spec->autocfg.speaker_pins[0] = 0x15;
9778         spec->automute = 1;
9779         spec->automute_mode = ALC_AUTOMUTE_AMP;
9780 }
9781
9782 /* toggle speaker-output according to the hp-jack state */
9783 static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9784 {
9785         struct alc_spec *spec = codec->spec;
9786
9787         spec->autocfg.hp_pins[0] = 0x14;
9788         spec->autocfg.speaker_pins[0] = 0x15;
9789         spec->automute = 1;
9790         spec->automute_mode = ALC_AUTOMUTE_AMP;
9791 }
9792
9793 /* toggle speaker-output according to the hp-jack state */
9794 #define alc883_targa_init_hook          alc882_targa_init_hook
9795 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9796
9797 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9798 {
9799         struct alc_spec *spec = codec->spec;
9800
9801         spec->autocfg.hp_pins[0] = 0x15;
9802         spec->autocfg.speaker_pins[0] = 0x14;
9803         spec->automute = 1;
9804         spec->automute_mode = ALC_AUTOMUTE_AMP;
9805 }
9806
9807 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9808 {
9809         alc_hp_automute(codec);
9810         alc88x_simple_mic_automute(codec);
9811 }
9812
9813 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9814                                            unsigned int res)
9815 {
9816         switch (res >> 26) {
9817         case ALC880_MIC_EVENT:
9818                 alc88x_simple_mic_automute(codec);
9819                 break;
9820         default:
9821                 alc_sku_unsol_event(codec, res);
9822                 break;
9823         }
9824 }
9825
9826 /* toggle speaker-output according to the hp-jack state */
9827 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9828 {
9829         struct alc_spec *spec = codec->spec;
9830
9831         spec->autocfg.hp_pins[0] = 0x14;
9832         spec->autocfg.speaker_pins[0] = 0x15;
9833         spec->automute = 1;
9834         spec->automute_mode = ALC_AUTOMUTE_AMP;
9835 }
9836
9837 static void alc883_haier_w66_setup(struct hda_codec *codec)
9838 {
9839         struct alc_spec *spec = codec->spec;
9840
9841         spec->autocfg.hp_pins[0] = 0x1b;
9842         spec->autocfg.speaker_pins[0] = 0x14;
9843         spec->automute = 1;
9844         spec->automute_mode = ALC_AUTOMUTE_AMP;
9845 }
9846
9847 static void alc883_lenovo_101e_setup(struct hda_codec *codec)
9848 {
9849         struct alc_spec *spec = codec->spec;
9850
9851         spec->autocfg.hp_pins[0] = 0x1b;
9852         spec->autocfg.line_out_pins[0] = 0x14;
9853         spec->autocfg.speaker_pins[0] = 0x15;
9854         spec->automute = 1;
9855         spec->detect_line = 1;
9856         spec->automute_lines = 1;
9857         spec->automute_mode = ALC_AUTOMUTE_AMP;
9858 }
9859
9860 /* toggle speaker-output according to the hp-jack state */
9861 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9862 {
9863         struct alc_spec *spec = codec->spec;
9864
9865         spec->autocfg.hp_pins[0] = 0x14;
9866         spec->autocfg.speaker_pins[0] = 0x15;
9867         spec->autocfg.speaker_pins[1] = 0x16;
9868         spec->automute = 1;
9869         spec->automute_mode = ALC_AUTOMUTE_AMP;
9870 }
9871
9872 static const struct hda_verb alc883_acer_eapd_verbs[] = {
9873         /* HP Pin: output 0 (0x0c) */
9874         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9875         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9876         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9877         /* Front Pin: output 0 (0x0c) */
9878         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9879         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9880         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9881         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9882         /* eanable EAPD on medion laptop */
9883         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9884         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9885         /* enable unsolicited event */
9886         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9887         { }
9888 };
9889
9890 static void alc888_6st_dell_setup(struct hda_codec *codec)
9891 {
9892         struct alc_spec *spec = codec->spec;
9893
9894         spec->autocfg.hp_pins[0] = 0x1b;
9895         spec->autocfg.speaker_pins[0] = 0x14;
9896         spec->autocfg.speaker_pins[1] = 0x15;
9897         spec->autocfg.speaker_pins[2] = 0x16;
9898         spec->autocfg.speaker_pins[3] = 0x17;
9899         spec->automute = 1;
9900         spec->automute_mode = ALC_AUTOMUTE_AMP;
9901 }
9902
9903 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9904 {
9905         struct alc_spec *spec = codec->spec;
9906
9907         spec->autocfg.hp_pins[0] = 0x1b;
9908         spec->autocfg.speaker_pins[0] = 0x14;
9909         spec->autocfg.speaker_pins[1] = 0x15;
9910         spec->autocfg.speaker_pins[2] = 0x16;
9911         spec->autocfg.speaker_pins[3] = 0x17;
9912         spec->autocfg.speaker_pins[4] = 0x1a;
9913         spec->automute = 1;
9914         spec->automute_mode = ALC_AUTOMUTE_AMP;
9915 }
9916
9917 static void alc883_vaiott_setup(struct hda_codec *codec)
9918 {
9919         struct alc_spec *spec = codec->spec;
9920
9921         spec->autocfg.hp_pins[0] = 0x15;
9922         spec->autocfg.speaker_pins[0] = 0x14;
9923         spec->autocfg.speaker_pins[1] = 0x17;
9924         spec->automute = 1;
9925         spec->automute_mode = ALC_AUTOMUTE_AMP;
9926 }
9927
9928 static const struct hda_verb alc888_asus_m90v_verbs[] = {
9929         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9930         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9931         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9932         /* enable unsolicited event */
9933         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9934         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9935         { } /* end */
9936 };
9937
9938 static void alc883_mode2_setup(struct hda_codec *codec)
9939 {
9940         struct alc_spec *spec = codec->spec;
9941
9942         spec->autocfg.hp_pins[0] = 0x1b;
9943         spec->autocfg.speaker_pins[0] = 0x14;
9944         spec->autocfg.speaker_pins[1] = 0x15;
9945         spec->autocfg.speaker_pins[2] = 0x16;
9946         spec->ext_mic.pin = 0x18;
9947         spec->int_mic.pin = 0x19;
9948         spec->ext_mic.mux_idx = 0;
9949         spec->int_mic.mux_idx = 1;
9950         spec->auto_mic = 1;
9951         spec->automute = 1;
9952         spec->automute_mode = ALC_AUTOMUTE_AMP;
9953 }
9954
9955 static const struct hda_verb alc888_asus_eee1601_verbs[] = {
9956         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9957         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9958         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9959         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9960         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9961         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9962         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9963         /* enable unsolicited event */
9964         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9965         { } /* end */
9966 };
9967
9968 static void alc883_eee1601_inithook(struct hda_codec *codec)
9969 {
9970         struct alc_spec *spec = codec->spec;
9971
9972         spec->autocfg.hp_pins[0] = 0x14;
9973         spec->autocfg.speaker_pins[0] = 0x1b;
9974         alc_hp_automute(codec);
9975 }
9976
9977 static const struct hda_verb alc889A_mb31_verbs[] = {
9978         /* Init rear pin (used as headphone output) */
9979         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9980         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9981         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9982         /* Init line pin (used as output in 4ch and 6ch mode) */
9983         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9984         /* Init line 2 pin (used as headphone out by default) */
9985         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9986         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9987         { } /* end */
9988 };
9989
9990 /* Mute speakers according to the headphone jack state */
9991 static void alc889A_mb31_automute(struct hda_codec *codec)
9992 {
9993         unsigned int present;
9994
9995         /* Mute only in 2ch or 4ch mode */
9996         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9997             == 0x00) {
9998                 present = snd_hda_jack_detect(codec, 0x15);
9999                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
10000                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
10001                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10002                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
10003         }
10004 }
10005
10006 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
10007 {
10008         if ((res >> 26) == ALC880_HP_EVENT)
10009                 alc889A_mb31_automute(codec);
10010 }
10011
10012
10013 #ifdef CONFIG_SND_HDA_POWER_SAVE
10014 #define alc882_loopbacks        alc880_loopbacks
10015 #endif
10016
10017 /* pcm configuration: identical with ALC880 */
10018 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
10019 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
10020 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
10021 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
10022
10023 static const hda_nid_t alc883_slave_dig_outs[] = {
10024         ALC1200_DIGOUT_NID, 0,
10025 };
10026
10027 static const hda_nid_t alc1200_slave_dig_outs[] = {
10028         ALC883_DIGOUT_NID, 0,
10029 };
10030
10031 /*
10032  * configuration and preset
10033  */
10034 static const char * const alc882_models[ALC882_MODEL_LAST] = {
10035         [ALC882_3ST_DIG]        = "3stack-dig",
10036         [ALC882_6ST_DIG]        = "6stack-dig",
10037         [ALC882_ARIMA]          = "arima",
10038         [ALC882_W2JC]           = "w2jc",
10039         [ALC882_TARGA]          = "targa",
10040         [ALC882_ASUS_A7J]       = "asus-a7j",
10041         [ALC882_ASUS_A7M]       = "asus-a7m",
10042         [ALC885_MACPRO]         = "macpro",
10043         [ALC885_MB5]            = "mb5",
10044         [ALC885_MACMINI3]       = "macmini3",
10045         [ALC885_MBA21]          = "mba21",
10046         [ALC885_MBP3]           = "mbp3",
10047         [ALC885_IMAC24]         = "imac24",
10048         [ALC885_IMAC91]         = "imac91",
10049         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
10050         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
10051         [ALC883_3ST_6ch]        = "3stack-6ch",
10052         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
10053         [ALC883_TARGA_DIG]      = "targa-dig",
10054         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
10055         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
10056         [ALC883_ACER]           = "acer",
10057         [ALC883_ACER_ASPIRE]    = "acer-aspire",
10058         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
10059         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
10060         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
10061         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
10062         [ALC883_MEDION]         = "medion",
10063         [ALC883_MEDION_WIM2160] = "medion-wim2160",
10064         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
10065         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
10066         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
10067         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
10068         [ALC888_LENOVO_SKY] = "lenovo-sky",
10069         [ALC883_HAIER_W66]      = "haier-w66",
10070         [ALC888_3ST_HP]         = "3stack-hp",
10071         [ALC888_6ST_DELL]       = "6stack-dell",
10072         [ALC883_MITAC]          = "mitac",
10073         [ALC883_CLEVO_M540R]    = "clevo-m540r",
10074         [ALC883_CLEVO_M720]     = "clevo-m720",
10075         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
10076         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
10077         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
10078         [ALC889A_INTEL]         = "intel-alc889a",
10079         [ALC889_INTEL]          = "intel-x58",
10080         [ALC1200_ASUS_P5Q]      = "asus-p5q",
10081         [ALC889A_MB31]          = "mb31",
10082         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
10083         [ALC882_AUTO]           = "auto",
10084 };
10085
10086 static const struct snd_pci_quirk alc882_cfg_tbl[] = {
10087         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
10088
10089         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
10090         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
10091         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
10092         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
10093         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
10094         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
10095         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
10096                 ALC888_ACER_ASPIRE_4930G),
10097         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
10098                 ALC888_ACER_ASPIRE_4930G),
10099         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
10100                 ALC888_ACER_ASPIRE_8930G),
10101         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
10102                 ALC888_ACER_ASPIRE_8930G),
10103         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
10104         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
10105         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
10106                 ALC888_ACER_ASPIRE_6530G),
10107         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
10108                 ALC888_ACER_ASPIRE_6530G),
10109         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
10110                 ALC888_ACER_ASPIRE_7730G),
10111         /* default Acer -- disabled as it causes more problems.
10112          *    model=auto should work fine now
10113          */
10114         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
10115
10116         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
10117
10118         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavilion", ALC883_6ST_DIG),
10119         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
10120         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
10121         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
10122         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
10123         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
10124
10125         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
10126         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
10127         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
10128         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
10129         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
10130         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
10131         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
10132         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
10133         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
10134         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
10135         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
10136
10137         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
10138         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
10139         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
10140         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
10141         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
10142         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
10143         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
10144         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
10145         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
10146
10147         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
10148         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
10149         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
10150         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
10151         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
10152         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
10153         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
10154         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
10155         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
10156         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
10157         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
10158         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
10159         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
10160         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
10161         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
10162         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
10163         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
10164         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
10165         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
10166         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
10167         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
10168         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
10169         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
10170         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
10171         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
10172         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
10173         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
10174         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
10175         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
10176         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
10177         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
10178
10179         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
10180         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
10181         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
10182         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
10183         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
10184         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
10185         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
10186         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
10187         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
10188         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
10189                       ALC883_FUJITSU_PI2515),
10190         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
10191                 ALC888_FUJITSU_XA3530),
10192         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
10193         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10194         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10195         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10196         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
10197         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
10198         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
10199         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
10200
10201         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
10202         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
10203         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
10204         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
10205         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
10206         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
10207         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
10208
10209         {}
10210 };
10211
10212 /* codec SSID table for Intel Mac */
10213 static const struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
10214         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
10215         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
10216         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
10217         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
10218         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
10219         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
10220         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
10221         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
10222         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
10223         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
10224         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
10225         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
10226         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
10227         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
10228         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
10229         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
10230         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
10231         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
10232          * so apparently no perfect solution yet
10233          */
10234         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
10235         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
10236         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
10237         {} /* terminator */
10238 };
10239
10240 static const struct alc_config_preset alc882_presets[] = {
10241         [ALC882_3ST_DIG] = {
10242                 .mixers = { alc882_base_mixer },
10243                 .init_verbs = { alc882_base_init_verbs,
10244                                 alc882_adc1_init_verbs },
10245                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10246                 .dac_nids = alc882_dac_nids,
10247                 .dig_out_nid = ALC882_DIGOUT_NID,
10248                 .dig_in_nid = ALC882_DIGIN_NID,
10249                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10250                 .channel_mode = alc882_ch_modes,
10251                 .need_dac_fix = 1,
10252                 .input_mux = &alc882_capture_source,
10253         },
10254         [ALC882_6ST_DIG] = {
10255                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10256                 .init_verbs = { alc882_base_init_verbs,
10257                                 alc882_adc1_init_verbs },
10258                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10259                 .dac_nids = alc882_dac_nids,
10260                 .dig_out_nid = ALC882_DIGOUT_NID,
10261                 .dig_in_nid = ALC882_DIGIN_NID,
10262                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10263                 .channel_mode = alc882_sixstack_modes,
10264                 .input_mux = &alc882_capture_source,
10265         },
10266         [ALC882_ARIMA] = {
10267                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10268                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10269                                 alc882_eapd_verbs },
10270                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10271                 .dac_nids = alc882_dac_nids,
10272                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10273                 .channel_mode = alc882_sixstack_modes,
10274                 .input_mux = &alc882_capture_source,
10275         },
10276         [ALC882_W2JC] = {
10277                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
10278                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10279                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
10280                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10281                 .dac_nids = alc882_dac_nids,
10282                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10283                 .channel_mode = alc880_threestack_modes,
10284                 .need_dac_fix = 1,
10285                 .input_mux = &alc882_capture_source,
10286                 .dig_out_nid = ALC882_DIGOUT_NID,
10287         },
10288            [ALC885_MBA21] = {
10289                         .mixers = { alc885_mba21_mixer },
10290                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
10291                         .num_dacs = 2,
10292                         .dac_nids = alc882_dac_nids,
10293                         .channel_mode = alc885_mba21_ch_modes,
10294                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10295                         .input_mux = &alc882_capture_source,
10296                         .unsol_event = alc_sku_unsol_event,
10297                         .setup = alc885_mba21_setup,
10298                         .init_hook = alc_hp_automute,
10299        },
10300         [ALC885_MBP3] = {
10301                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
10302                 .init_verbs = { alc885_mbp3_init_verbs,
10303                                 alc880_gpio1_init_verbs },
10304                 .num_dacs = 2,
10305                 .dac_nids = alc882_dac_nids,
10306                 .hp_nid = 0x04,
10307                 .channel_mode = alc885_mbp_4ch_modes,
10308                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10309                 .input_mux = &alc882_capture_source,
10310                 .dig_out_nid = ALC882_DIGOUT_NID,
10311                 .dig_in_nid = ALC882_DIGIN_NID,
10312                 .unsol_event = alc_sku_unsol_event,
10313                 .setup = alc885_mbp3_setup,
10314                 .init_hook = alc_hp_automute,
10315         },
10316         [ALC885_MB5] = {
10317                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10318                 .init_verbs = { alc885_mb5_init_verbs,
10319                                 alc880_gpio1_init_verbs },
10320                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10321                 .dac_nids = alc882_dac_nids,
10322                 .channel_mode = alc885_mb5_6ch_modes,
10323                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10324                 .input_mux = &mb5_capture_source,
10325                 .dig_out_nid = ALC882_DIGOUT_NID,
10326                 .dig_in_nid = ALC882_DIGIN_NID,
10327                 .unsol_event = alc_sku_unsol_event,
10328                 .setup = alc885_mb5_setup,
10329                 .init_hook = alc_hp_automute,
10330         },
10331         [ALC885_MACMINI3] = {
10332                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10333                 .init_verbs = { alc885_macmini3_init_verbs,
10334                                 alc880_gpio1_init_verbs },
10335                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10336                 .dac_nids = alc882_dac_nids,
10337                 .channel_mode = alc885_macmini3_6ch_modes,
10338                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10339                 .input_mux = &macmini3_capture_source,
10340                 .dig_out_nid = ALC882_DIGOUT_NID,
10341                 .dig_in_nid = ALC882_DIGIN_NID,
10342                 .unsol_event = alc_sku_unsol_event,
10343                 .setup = alc885_macmini3_setup,
10344                 .init_hook = alc_hp_automute,
10345         },
10346         [ALC885_MACPRO] = {
10347                 .mixers = { alc882_macpro_mixer },
10348                 .init_verbs = { alc882_macpro_init_verbs },
10349                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10350                 .dac_nids = alc882_dac_nids,
10351                 .dig_out_nid = ALC882_DIGOUT_NID,
10352                 .dig_in_nid = ALC882_DIGIN_NID,
10353                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10354                 .channel_mode = alc882_ch_modes,
10355                 .input_mux = &alc882_capture_source,
10356                 .init_hook = alc885_macpro_init_hook,
10357         },
10358         [ALC885_IMAC24] = {
10359                 .mixers = { alc885_imac24_mixer },
10360                 .init_verbs = { alc885_imac24_init_verbs },
10361                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10362                 .dac_nids = alc882_dac_nids,
10363                 .dig_out_nid = ALC882_DIGOUT_NID,
10364                 .dig_in_nid = ALC882_DIGIN_NID,
10365                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10366                 .channel_mode = alc882_ch_modes,
10367                 .input_mux = &alc882_capture_source,
10368                 .unsol_event = alc_sku_unsol_event,
10369                 .setup = alc885_imac24_setup,
10370                 .init_hook = alc885_imac24_init_hook,
10371         },
10372         [ALC885_IMAC91] = {
10373                 .mixers = {alc885_imac91_mixer},
10374                 .init_verbs = { alc885_imac91_init_verbs,
10375                                 alc880_gpio1_init_verbs },
10376                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10377                 .dac_nids = alc882_dac_nids,
10378                 .channel_mode = alc885_mba21_ch_modes,
10379                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10380                 .input_mux = &alc889A_imac91_capture_source,
10381                 .dig_out_nid = ALC882_DIGOUT_NID,
10382                 .dig_in_nid = ALC882_DIGIN_NID,
10383                 .unsol_event = alc_sku_unsol_event,
10384                 .setup = alc885_imac91_setup,
10385                 .init_hook = alc_hp_automute,
10386         },
10387         [ALC882_TARGA] = {
10388                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10389                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10390                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
10391                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10392                 .dac_nids = alc882_dac_nids,
10393                 .dig_out_nid = ALC882_DIGOUT_NID,
10394                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10395                 .adc_nids = alc882_adc_nids,
10396                 .capsrc_nids = alc882_capsrc_nids,
10397                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10398                 .channel_mode = alc882_3ST_6ch_modes,
10399                 .need_dac_fix = 1,
10400                 .input_mux = &alc882_capture_source,
10401                 .unsol_event = alc_sku_unsol_event,
10402                 .setup = alc882_targa_setup,
10403                 .init_hook = alc882_targa_automute,
10404         },
10405         [ALC882_ASUS_A7J] = {
10406                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10407                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10408                                 alc882_asus_a7j_verbs},
10409                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10410                 .dac_nids = alc882_dac_nids,
10411                 .dig_out_nid = ALC882_DIGOUT_NID,
10412                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10413                 .adc_nids = alc882_adc_nids,
10414                 .capsrc_nids = alc882_capsrc_nids,
10415                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10416                 .channel_mode = alc882_3ST_6ch_modes,
10417                 .need_dac_fix = 1,
10418                 .input_mux = &alc882_capture_source,
10419         },
10420         [ALC882_ASUS_A7M] = {
10421                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10422                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10423                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10424                                 alc882_asus_a7m_verbs },
10425                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10426                 .dac_nids = alc882_dac_nids,
10427                 .dig_out_nid = ALC882_DIGOUT_NID,
10428                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10429                 .channel_mode = alc880_threestack_modes,
10430                 .need_dac_fix = 1,
10431                 .input_mux = &alc882_capture_source,
10432         },
10433         [ALC883_3ST_2ch_DIG] = {
10434                 .mixers = { alc883_3ST_2ch_mixer },
10435                 .init_verbs = { alc883_init_verbs },
10436                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10437                 .dac_nids = alc883_dac_nids,
10438                 .dig_out_nid = ALC883_DIGOUT_NID,
10439                 .dig_in_nid = ALC883_DIGIN_NID,
10440                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10441                 .channel_mode = alc883_3ST_2ch_modes,
10442                 .input_mux = &alc883_capture_source,
10443         },
10444         [ALC883_3ST_6ch_DIG] = {
10445                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10446                 .init_verbs = { alc883_init_verbs },
10447                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10448                 .dac_nids = alc883_dac_nids,
10449                 .dig_out_nid = ALC883_DIGOUT_NID,
10450                 .dig_in_nid = ALC883_DIGIN_NID,
10451                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10452                 .channel_mode = alc883_3ST_6ch_modes,
10453                 .need_dac_fix = 1,
10454                 .input_mux = &alc883_capture_source,
10455         },
10456         [ALC883_3ST_6ch] = {
10457                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10458                 .init_verbs = { alc883_init_verbs },
10459                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10460                 .dac_nids = alc883_dac_nids,
10461                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10462                 .channel_mode = alc883_3ST_6ch_modes,
10463                 .need_dac_fix = 1,
10464                 .input_mux = &alc883_capture_source,
10465         },
10466         [ALC883_3ST_6ch_INTEL] = {
10467                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10468                 .init_verbs = { alc883_init_verbs },
10469                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10470                 .dac_nids = alc883_dac_nids,
10471                 .dig_out_nid = ALC883_DIGOUT_NID,
10472                 .dig_in_nid = ALC883_DIGIN_NID,
10473                 .slave_dig_outs = alc883_slave_dig_outs,
10474                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10475                 .channel_mode = alc883_3ST_6ch_intel_modes,
10476                 .need_dac_fix = 1,
10477                 .input_mux = &alc883_3stack_6ch_intel,
10478         },
10479         [ALC889A_INTEL] = {
10480                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10481                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10482                                 alc_hp15_unsol_verbs },
10483                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10484                 .dac_nids = alc883_dac_nids,
10485                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10486                 .adc_nids = alc889_adc_nids,
10487                 .dig_out_nid = ALC883_DIGOUT_NID,
10488                 .dig_in_nid = ALC883_DIGIN_NID,
10489                 .slave_dig_outs = alc883_slave_dig_outs,
10490                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10491                 .channel_mode = alc889_8ch_intel_modes,
10492                 .capsrc_nids = alc889_capsrc_nids,
10493                 .input_mux = &alc889_capture_source,
10494                 .setup = alc889_automute_setup,
10495                 .init_hook = alc_hp_automute,
10496                 .unsol_event = alc_sku_unsol_event,
10497                 .need_dac_fix = 1,
10498         },
10499         [ALC889_INTEL] = {
10500                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10501                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10502                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10503                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10504                 .dac_nids = alc883_dac_nids,
10505                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10506                 .adc_nids = alc889_adc_nids,
10507                 .dig_out_nid = ALC883_DIGOUT_NID,
10508                 .dig_in_nid = ALC883_DIGIN_NID,
10509                 .slave_dig_outs = alc883_slave_dig_outs,
10510                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10511                 .channel_mode = alc889_8ch_intel_modes,
10512                 .capsrc_nids = alc889_capsrc_nids,
10513                 .input_mux = &alc889_capture_source,
10514                 .setup = alc889_automute_setup,
10515                 .init_hook = alc889_intel_init_hook,
10516                 .unsol_event = alc_sku_unsol_event,
10517                 .need_dac_fix = 1,
10518         },
10519         [ALC883_6ST_DIG] = {
10520                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10521                 .init_verbs = { alc883_init_verbs },
10522                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10523                 .dac_nids = alc883_dac_nids,
10524                 .dig_out_nid = ALC883_DIGOUT_NID,
10525                 .dig_in_nid = ALC883_DIGIN_NID,
10526                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10527                 .channel_mode = alc883_sixstack_modes,
10528                 .input_mux = &alc883_capture_source,
10529         },
10530         [ALC883_TARGA_DIG] = {
10531                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10532                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10533                                 alc883_targa_verbs},
10534                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10535                 .dac_nids = alc883_dac_nids,
10536                 .dig_out_nid = ALC883_DIGOUT_NID,
10537                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10538                 .channel_mode = alc883_3ST_6ch_modes,
10539                 .need_dac_fix = 1,
10540                 .input_mux = &alc883_capture_source,
10541                 .unsol_event = alc883_targa_unsol_event,
10542                 .setup = alc882_targa_setup,
10543                 .init_hook = alc882_targa_automute,
10544         },
10545         [ALC883_TARGA_2ch_DIG] = {
10546                 .mixers = { alc883_targa_2ch_mixer},
10547                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10548                                 alc883_targa_verbs},
10549                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10550                 .dac_nids = alc883_dac_nids,
10551                 .adc_nids = alc883_adc_nids_alt,
10552                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10553                 .capsrc_nids = alc883_capsrc_nids,
10554                 .dig_out_nid = ALC883_DIGOUT_NID,
10555                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10556                 .channel_mode = alc883_3ST_2ch_modes,
10557                 .input_mux = &alc883_capture_source,
10558                 .unsol_event = alc883_targa_unsol_event,
10559                 .setup = alc882_targa_setup,
10560                 .init_hook = alc882_targa_automute,
10561         },
10562         [ALC883_TARGA_8ch_DIG] = {
10563                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10564                             alc883_chmode_mixer },
10565                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10566                                 alc883_targa_verbs },
10567                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10568                 .dac_nids = alc883_dac_nids,
10569                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10570                 .adc_nids = alc883_adc_nids_rev,
10571                 .capsrc_nids = alc883_capsrc_nids_rev,
10572                 .dig_out_nid = ALC883_DIGOUT_NID,
10573                 .dig_in_nid = ALC883_DIGIN_NID,
10574                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10575                 .channel_mode = alc883_4ST_8ch_modes,
10576                 .need_dac_fix = 1,
10577                 .input_mux = &alc883_capture_source,
10578                 .unsol_event = alc883_targa_unsol_event,
10579                 .setup = alc882_targa_setup,
10580                 .init_hook = alc882_targa_automute,
10581         },
10582         [ALC883_ACER] = {
10583                 .mixers = { alc883_base_mixer },
10584                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10585                  * and the headphone jack.  Turn this on and rely on the
10586                  * standard mute methods whenever the user wants to turn
10587                  * these outputs off.
10588                  */
10589                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10590                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10591                 .dac_nids = alc883_dac_nids,
10592                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10593                 .channel_mode = alc883_3ST_2ch_modes,
10594                 .input_mux = &alc883_capture_source,
10595         },
10596         [ALC883_ACER_ASPIRE] = {
10597                 .mixers = { alc883_acer_aspire_mixer },
10598                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10599                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10600                 .dac_nids = alc883_dac_nids,
10601                 .dig_out_nid = ALC883_DIGOUT_NID,
10602                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10603                 .channel_mode = alc883_3ST_2ch_modes,
10604                 .input_mux = &alc883_capture_source,
10605                 .unsol_event = alc_sku_unsol_event,
10606                 .setup = alc883_acer_aspire_setup,
10607                 .init_hook = alc_hp_automute,
10608         },
10609         [ALC888_ACER_ASPIRE_4930G] = {
10610                 .mixers = { alc888_acer_aspire_4930g_mixer,
10611                                 alc883_chmode_mixer },
10612                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10613                                 alc888_acer_aspire_4930g_verbs },
10614                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10615                 .dac_nids = alc883_dac_nids,
10616                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10617                 .adc_nids = alc883_adc_nids_rev,
10618                 .capsrc_nids = alc883_capsrc_nids_rev,
10619                 .dig_out_nid = ALC883_DIGOUT_NID,
10620                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10621                 .channel_mode = alc883_3ST_6ch_modes,
10622                 .need_dac_fix = 1,
10623                 .const_channel_count = 6,
10624                 .num_mux_defs =
10625                         ARRAY_SIZE(alc888_2_capture_sources),
10626                 .input_mux = alc888_2_capture_sources,
10627                 .unsol_event = alc_sku_unsol_event,
10628                 .setup = alc888_acer_aspire_4930g_setup,
10629                 .init_hook = alc_hp_automute,
10630         },
10631         [ALC888_ACER_ASPIRE_6530G] = {
10632                 .mixers = { alc888_acer_aspire_6530_mixer },
10633                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10634                                 alc888_acer_aspire_6530g_verbs },
10635                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10636                 .dac_nids = alc883_dac_nids,
10637                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10638                 .adc_nids = alc883_adc_nids_rev,
10639                 .capsrc_nids = alc883_capsrc_nids_rev,
10640                 .dig_out_nid = ALC883_DIGOUT_NID,
10641                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10642                 .channel_mode = alc883_3ST_2ch_modes,
10643                 .num_mux_defs =
10644                         ARRAY_SIZE(alc888_2_capture_sources),
10645                 .input_mux = alc888_acer_aspire_6530_sources,
10646                 .unsol_event = alc_sku_unsol_event,
10647                 .setup = alc888_acer_aspire_6530g_setup,
10648                 .init_hook = alc_hp_automute,
10649         },
10650         [ALC888_ACER_ASPIRE_8930G] = {
10651                 .mixers = { alc889_acer_aspire_8930g_mixer,
10652                                 alc883_chmode_mixer },
10653                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10654                                 alc889_acer_aspire_8930g_verbs,
10655                                 alc889_eapd_verbs},
10656                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10657                 .dac_nids = alc883_dac_nids,
10658                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10659                 .adc_nids = alc889_adc_nids,
10660                 .capsrc_nids = alc889_capsrc_nids,
10661                 .dig_out_nid = ALC883_DIGOUT_NID,
10662                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10663                 .channel_mode = alc883_3ST_6ch_modes,
10664                 .need_dac_fix = 1,
10665                 .const_channel_count = 6,
10666                 .num_mux_defs =
10667                         ARRAY_SIZE(alc889_capture_sources),
10668                 .input_mux = alc889_capture_sources,
10669                 .unsol_event = alc_sku_unsol_event,
10670                 .setup = alc889_acer_aspire_8930g_setup,
10671                 .init_hook = alc_hp_automute,
10672 #ifdef CONFIG_SND_HDA_POWER_SAVE
10673                 .power_hook = alc_power_eapd,
10674 #endif
10675         },
10676         [ALC888_ACER_ASPIRE_7730G] = {
10677                 .mixers = { alc883_3ST_6ch_mixer,
10678                                 alc883_chmode_mixer },
10679                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10680                                 alc888_acer_aspire_7730G_verbs },
10681                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10682                 .dac_nids = alc883_dac_nids,
10683                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10684                 .adc_nids = alc883_adc_nids_rev,
10685                 .capsrc_nids = alc883_capsrc_nids_rev,
10686                 .dig_out_nid = ALC883_DIGOUT_NID,
10687                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10688                 .channel_mode = alc883_3ST_6ch_modes,
10689                 .need_dac_fix = 1,
10690                 .const_channel_count = 6,
10691                 .input_mux = &alc883_capture_source,
10692                 .unsol_event = alc_sku_unsol_event,
10693                 .setup = alc888_acer_aspire_7730g_setup,
10694                 .init_hook = alc_hp_automute,
10695         },
10696         [ALC883_MEDION] = {
10697                 .mixers = { alc883_fivestack_mixer,
10698                             alc883_chmode_mixer },
10699                 .init_verbs = { alc883_init_verbs,
10700                                 alc883_medion_eapd_verbs },
10701                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10702                 .dac_nids = alc883_dac_nids,
10703                 .adc_nids = alc883_adc_nids_alt,
10704                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10705                 .capsrc_nids = alc883_capsrc_nids,
10706                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10707                 .channel_mode = alc883_sixstack_modes,
10708                 .input_mux = &alc883_capture_source,
10709         },
10710         [ALC883_MEDION_WIM2160] = {
10711                 .mixers = { alc883_medion_wim2160_mixer },
10712                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10713                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10714                 .dac_nids = alc883_dac_nids,
10715                 .dig_out_nid = ALC883_DIGOUT_NID,
10716                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10717                 .adc_nids = alc883_adc_nids,
10718                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10719                 .channel_mode = alc883_3ST_2ch_modes,
10720                 .input_mux = &alc883_capture_source,
10721                 .unsol_event = alc_sku_unsol_event,
10722                 .setup = alc883_medion_wim2160_setup,
10723                 .init_hook = alc_hp_automute,
10724         },
10725         [ALC883_LAPTOP_EAPD] = {
10726                 .mixers = { alc883_base_mixer },
10727                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10728                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10729                 .dac_nids = alc883_dac_nids,
10730                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10731                 .channel_mode = alc883_3ST_2ch_modes,
10732                 .input_mux = &alc883_capture_source,
10733         },
10734         [ALC883_CLEVO_M540R] = {
10735                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10736                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10737                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10738                 .dac_nids = alc883_dac_nids,
10739                 .dig_out_nid = ALC883_DIGOUT_NID,
10740                 .dig_in_nid = ALC883_DIGIN_NID,
10741                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10742                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10743                 .need_dac_fix = 1,
10744                 .input_mux = &alc883_capture_source,
10745                 /* This machine has the hardware HP auto-muting, thus
10746                  * we need no software mute via unsol event
10747                  */
10748         },
10749         [ALC883_CLEVO_M720] = {
10750                 .mixers = { alc883_clevo_m720_mixer },
10751                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10752                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10753                 .dac_nids = alc883_dac_nids,
10754                 .dig_out_nid = ALC883_DIGOUT_NID,
10755                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10756                 .channel_mode = alc883_3ST_2ch_modes,
10757                 .input_mux = &alc883_capture_source,
10758                 .unsol_event = alc883_clevo_m720_unsol_event,
10759                 .setup = alc883_clevo_m720_setup,
10760                 .init_hook = alc883_clevo_m720_init_hook,
10761         },
10762         [ALC883_LENOVO_101E_2ch] = {
10763                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10764                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10765                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10766                 .dac_nids = alc883_dac_nids,
10767                 .adc_nids = alc883_adc_nids_alt,
10768                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10769                 .capsrc_nids = alc883_capsrc_nids,
10770                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10771                 .channel_mode = alc883_3ST_2ch_modes,
10772                 .input_mux = &alc883_lenovo_101e_capture_source,
10773                 .setup = alc883_lenovo_101e_setup,
10774                 .unsol_event = alc_sku_unsol_event,
10775                 .init_hook = alc_inithook,
10776         },
10777         [ALC883_LENOVO_NB0763] = {
10778                 .mixers = { alc883_lenovo_nb0763_mixer },
10779                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10780                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10781                 .dac_nids = alc883_dac_nids,
10782                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10783                 .channel_mode = alc883_3ST_2ch_modes,
10784                 .need_dac_fix = 1,
10785                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10786                 .unsol_event = alc_sku_unsol_event,
10787                 .setup = alc883_lenovo_nb0763_setup,
10788                 .init_hook = alc_hp_automute,
10789         },
10790         [ALC888_LENOVO_MS7195_DIG] = {
10791                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10792                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10793                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10794                 .dac_nids = alc883_dac_nids,
10795                 .dig_out_nid = ALC883_DIGOUT_NID,
10796                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10797                 .channel_mode = alc883_3ST_6ch_modes,
10798                 .need_dac_fix = 1,
10799                 .input_mux = &alc883_capture_source,
10800                 .unsol_event = alc_sku_unsol_event,
10801                 .setup = alc888_lenovo_ms7195_setup,
10802                 .init_hook = alc_inithook,
10803         },
10804         [ALC883_HAIER_W66] = {
10805                 .mixers = { alc883_targa_2ch_mixer},
10806                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10807                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10808                 .dac_nids = alc883_dac_nids,
10809                 .dig_out_nid = ALC883_DIGOUT_NID,
10810                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10811                 .channel_mode = alc883_3ST_2ch_modes,
10812                 .input_mux = &alc883_capture_source,
10813                 .unsol_event = alc_sku_unsol_event,
10814                 .setup = alc883_haier_w66_setup,
10815                 .init_hook = alc_hp_automute,
10816         },
10817         [ALC888_3ST_HP] = {
10818                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10819                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10820                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10821                 .dac_nids = alc883_dac_nids,
10822                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10823                 .channel_mode = alc888_3st_hp_modes,
10824                 .need_dac_fix = 1,
10825                 .input_mux = &alc883_capture_source,
10826                 .unsol_event = alc_sku_unsol_event,
10827                 .setup = alc888_3st_hp_setup,
10828                 .init_hook = alc_hp_automute,
10829         },
10830         [ALC888_6ST_DELL] = {
10831                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10832                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10833                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10834                 .dac_nids = alc883_dac_nids,
10835                 .dig_out_nid = ALC883_DIGOUT_NID,
10836                 .dig_in_nid = ALC883_DIGIN_NID,
10837                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10838                 .channel_mode = alc883_sixstack_modes,
10839                 .input_mux = &alc883_capture_source,
10840                 .unsol_event = alc_sku_unsol_event,
10841                 .setup = alc888_6st_dell_setup,
10842                 .init_hook = alc_hp_automute,
10843         },
10844         [ALC883_MITAC] = {
10845                 .mixers = { alc883_mitac_mixer },
10846                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10847                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10848                 .dac_nids = alc883_dac_nids,
10849                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10850                 .channel_mode = alc883_3ST_2ch_modes,
10851                 .input_mux = &alc883_capture_source,
10852                 .unsol_event = alc_sku_unsol_event,
10853                 .setup = alc883_mitac_setup,
10854                 .init_hook = alc_hp_automute,
10855         },
10856         [ALC883_FUJITSU_PI2515] = {
10857                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10858                 .init_verbs = { alc883_init_verbs,
10859                                 alc883_2ch_fujitsu_pi2515_verbs},
10860                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10861                 .dac_nids = alc883_dac_nids,
10862                 .dig_out_nid = ALC883_DIGOUT_NID,
10863                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10864                 .channel_mode = alc883_3ST_2ch_modes,
10865                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10866                 .unsol_event = alc_sku_unsol_event,
10867                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10868                 .init_hook = alc_hp_automute,
10869         },
10870         [ALC888_FUJITSU_XA3530] = {
10871                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10872                 .init_verbs = { alc883_init_verbs,
10873                         alc888_fujitsu_xa3530_verbs },
10874                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10875                 .dac_nids = alc883_dac_nids,
10876                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10877                 .adc_nids = alc883_adc_nids_rev,
10878                 .capsrc_nids = alc883_capsrc_nids_rev,
10879                 .dig_out_nid = ALC883_DIGOUT_NID,
10880                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10881                 .channel_mode = alc888_4ST_8ch_intel_modes,
10882                 .num_mux_defs =
10883                         ARRAY_SIZE(alc888_2_capture_sources),
10884                 .input_mux = alc888_2_capture_sources,
10885                 .unsol_event = alc_sku_unsol_event,
10886                 .setup = alc888_fujitsu_xa3530_setup,
10887                 .init_hook = alc_hp_automute,
10888         },
10889         [ALC888_LENOVO_SKY] = {
10890                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10891                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10892                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10893                 .dac_nids = alc883_dac_nids,
10894                 .dig_out_nid = ALC883_DIGOUT_NID,
10895                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10896                 .channel_mode = alc883_sixstack_modes,
10897                 .need_dac_fix = 1,
10898                 .input_mux = &alc883_lenovo_sky_capture_source,
10899                 .unsol_event = alc_sku_unsol_event,
10900                 .setup = alc888_lenovo_sky_setup,
10901                 .init_hook = alc_hp_automute,
10902         },
10903         [ALC888_ASUS_M90V] = {
10904                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10905                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10906                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10907                 .dac_nids = alc883_dac_nids,
10908                 .dig_out_nid = ALC883_DIGOUT_NID,
10909                 .dig_in_nid = ALC883_DIGIN_NID,
10910                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10911                 .channel_mode = alc883_3ST_6ch_modes,
10912                 .need_dac_fix = 1,
10913                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10914                 .unsol_event = alc_sku_unsol_event,
10915                 .setup = alc883_mode2_setup,
10916                 .init_hook = alc_inithook,
10917         },
10918         [ALC888_ASUS_EEE1601] = {
10919                 .mixers = { alc883_asus_eee1601_mixer },
10920                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10921                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10922                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10923                 .dac_nids = alc883_dac_nids,
10924                 .dig_out_nid = ALC883_DIGOUT_NID,
10925                 .dig_in_nid = ALC883_DIGIN_NID,
10926                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10927                 .channel_mode = alc883_3ST_2ch_modes,
10928                 .need_dac_fix = 1,
10929                 .input_mux = &alc883_asus_eee1601_capture_source,
10930                 .unsol_event = alc_sku_unsol_event,
10931                 .init_hook = alc883_eee1601_inithook,
10932         },
10933         [ALC1200_ASUS_P5Q] = {
10934                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10935                 .init_verbs = { alc883_init_verbs },
10936                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10937                 .dac_nids = alc883_dac_nids,
10938                 .dig_out_nid = ALC1200_DIGOUT_NID,
10939                 .dig_in_nid = ALC883_DIGIN_NID,
10940                 .slave_dig_outs = alc1200_slave_dig_outs,
10941                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10942                 .channel_mode = alc883_sixstack_modes,
10943                 .input_mux = &alc883_capture_source,
10944         },
10945         [ALC889A_MB31] = {
10946                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10947                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10948                         alc880_gpio1_init_verbs },
10949                 .adc_nids = alc883_adc_nids,
10950                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10951                 .capsrc_nids = alc883_capsrc_nids,
10952                 .dac_nids = alc883_dac_nids,
10953                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10954                 .channel_mode = alc889A_mb31_6ch_modes,
10955                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10956                 .input_mux = &alc889A_mb31_capture_source,
10957                 .dig_out_nid = ALC883_DIGOUT_NID,
10958                 .unsol_event = alc889A_mb31_unsol_event,
10959                 .init_hook = alc889A_mb31_automute,
10960         },
10961         [ALC883_SONY_VAIO_TT] = {
10962                 .mixers = { alc883_vaiott_mixer },
10963                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10964                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10965                 .dac_nids = alc883_dac_nids,
10966                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10967                 .channel_mode = alc883_3ST_2ch_modes,
10968                 .input_mux = &alc883_capture_source,
10969                 .unsol_event = alc_sku_unsol_event,
10970                 .setup = alc883_vaiott_setup,
10971                 .init_hook = alc_hp_automute,
10972         },
10973 };
10974
10975
10976 /*
10977  * Pin config fixes
10978  */
10979 enum {
10980         PINFIX_ABIT_AW9D_MAX,
10981         PINFIX_LENOVO_Y530,
10982         PINFIX_PB_M5210,
10983         PINFIX_ACER_ASPIRE_7736,
10984 };
10985
10986 static const struct alc_fixup alc882_fixups[] = {
10987         [PINFIX_ABIT_AW9D_MAX] = {
10988                 .type = ALC_FIXUP_PINS,
10989                 .v.pins = (const struct alc_pincfg[]) {
10990                         { 0x15, 0x01080104 }, /* side */
10991                         { 0x16, 0x01011012 }, /* rear */
10992                         { 0x17, 0x01016011 }, /* clfe */
10993                         { }
10994                 }
10995         },
10996         [PINFIX_LENOVO_Y530] = {
10997                 .type = ALC_FIXUP_PINS,
10998                 .v.pins = (const struct alc_pincfg[]) {
10999                         { 0x15, 0x99130112 }, /* rear int speakers */
11000                         { 0x16, 0x99130111 }, /* subwoofer */
11001                         { }
11002                 }
11003         },
11004         [PINFIX_PB_M5210] = {
11005                 .type = ALC_FIXUP_VERBS,
11006                 .v.verbs = (const struct hda_verb[]) {
11007                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
11008                         {}
11009                 }
11010         },
11011         [PINFIX_ACER_ASPIRE_7736] = {
11012                 .type = ALC_FIXUP_SKU,
11013                 .v.sku = ALC_FIXUP_SKU_IGNORE,
11014         },
11015 };
11016
11017 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
11018         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
11019         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
11020         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
11021         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
11022         {}
11023 };
11024
11025 /*
11026  * BIOS auto configuration
11027  */
11028 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
11029                                                 const struct auto_pin_cfg *cfg)
11030 {
11031         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
11032 }
11033
11034 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
11035                                               hda_nid_t nid, int pin_type,
11036                                               hda_nid_t dac)
11037 {
11038         int idx;
11039
11040         /* set as output */
11041         alc_set_pin_output(codec, nid, pin_type);
11042
11043         if (dac == 0x25)
11044                 idx = 4;
11045         else if (dac >= 0x02 && dac <= 0x05)
11046                 idx = dac - 2;
11047         else
11048                 return;
11049         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
11050 }
11051
11052 static void alc882_auto_init_multi_out(struct hda_codec *codec)
11053 {
11054         struct alc_spec *spec = codec->spec;
11055         int i;
11056
11057         for (i = 0; i <= HDA_SIDE; i++) {
11058                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
11059                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
11060                 if (nid)
11061                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
11062                                         spec->multiout.dac_nids[i]);
11063         }
11064 }
11065
11066 static void alc882_auto_init_hp_out(struct hda_codec *codec)
11067 {
11068         struct alc_spec *spec = codec->spec;
11069         hda_nid_t pin, dac;
11070         int i;
11071
11072         if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT) {
11073                 for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
11074                         pin = spec->autocfg.hp_pins[i];
11075                         if (!pin)
11076                                 break;
11077                         dac = spec->multiout.hp_nid;
11078                         if (!dac)
11079                                 dac = spec->multiout.dac_nids[0]; /* to front */
11080                         alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
11081                 }
11082         }
11083
11084         if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT) {
11085                 for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
11086                         pin = spec->autocfg.speaker_pins[i];
11087                         if (!pin)
11088                                 break;
11089                         dac = spec->multiout.extra_out_nid[0];
11090                         if (!dac)
11091                                 dac = spec->multiout.dac_nids[0]; /* to front */
11092                         alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
11093                 }
11094         }
11095 }
11096
11097 static void alc882_auto_init_analog_input(struct hda_codec *codec)
11098 {
11099         struct alc_spec *spec = codec->spec;
11100         struct auto_pin_cfg *cfg = &spec->autocfg;
11101         int i;
11102
11103         for (i = 0; i < cfg->num_inputs; i++) {
11104                 hda_nid_t nid = cfg->inputs[i].pin;
11105                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
11106                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
11107                         snd_hda_codec_write(codec, nid, 0,
11108                                             AC_VERB_SET_AMP_GAIN_MUTE,
11109                                             AMP_OUT_MUTE);
11110         }
11111 }
11112
11113 static void alc882_auto_init_input_src(struct hda_codec *codec)
11114 {
11115         struct alc_spec *spec = codec->spec;
11116         int c;
11117
11118         for (c = 0; c < spec->num_adc_nids; c++) {
11119                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
11120                 hda_nid_t nid = spec->capsrc_nids[c];
11121                 unsigned int mux_idx;
11122                 const struct hda_input_mux *imux;
11123                 int conns, mute, idx, item;
11124
11125                 /* mute ADC */
11126                 snd_hda_codec_write(codec, spec->adc_nids[c], 0,
11127                                     AC_VERB_SET_AMP_GAIN_MUTE,
11128                                     AMP_IN_MUTE(0));
11129
11130                 conns = snd_hda_get_connections(codec, nid, conn_list,
11131                                                 ARRAY_SIZE(conn_list));
11132                 if (conns < 0)
11133                         continue;
11134                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
11135                 imux = &spec->input_mux[mux_idx];
11136                 if (!imux->num_items && mux_idx > 0)
11137                         imux = &spec->input_mux[0];
11138                 for (idx = 0; idx < conns; idx++) {
11139                         /* if the current connection is the selected one,
11140                          * unmute it as default - otherwise mute it
11141                          */
11142                         mute = AMP_IN_MUTE(idx);
11143                         for (item = 0; item < imux->num_items; item++) {
11144                                 if (imux->items[item].index == idx) {
11145                                         if (spec->cur_mux[c] == item)
11146                                                 mute = AMP_IN_UNMUTE(idx);
11147                                         break;
11148                                 }
11149                         }
11150                         /* check if we have a selector or mixer
11151                          * we could check for the widget type instead, but
11152                          * just check for Amp-In presence (in case of mixer
11153                          * without amp-in there is something wrong, this
11154                          * function shouldn't be used or capsrc nid is wrong)
11155                          */
11156                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
11157                                 snd_hda_codec_write(codec, nid, 0,
11158                                                     AC_VERB_SET_AMP_GAIN_MUTE,
11159                                                     mute);
11160                         else if (mute != AMP_IN_MUTE(idx))
11161                                 snd_hda_codec_write(codec, nid, 0,
11162                                                     AC_VERB_SET_CONNECT_SEL,
11163                                                     idx);
11164                 }
11165         }
11166 }
11167
11168 /* add mic boosts if needed */
11169 static int alc_auto_add_mic_boost(struct hda_codec *codec)
11170 {
11171         struct alc_spec *spec = codec->spec;
11172         struct auto_pin_cfg *cfg = &spec->autocfg;
11173         int i, err;
11174         int type_idx = 0;
11175         hda_nid_t nid;
11176         const char *prev_label = NULL;
11177
11178         for (i = 0; i < cfg->num_inputs; i++) {
11179                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
11180                         break;
11181                 nid = cfg->inputs[i].pin;
11182                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
11183                         const char *label;
11184                         char boost_label[32];
11185
11186                         label = hda_get_autocfg_input_label(codec, cfg, i);
11187                         if (prev_label && !strcmp(label, prev_label))
11188                                 type_idx++;
11189                         else
11190                                 type_idx = 0;
11191                         prev_label = label;
11192
11193                         snprintf(boost_label, sizeof(boost_label),
11194                                  "%s Boost Volume", label);
11195                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
11196                                           boost_label, type_idx,
11197                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11198                         if (err < 0)
11199                                 return err;
11200                 }
11201         }
11202         return 0;
11203 }
11204
11205 /* almost identical with ALC880 parser... */
11206 static int alc882_parse_auto_config(struct hda_codec *codec)
11207 {
11208         struct alc_spec *spec = codec->spec;
11209         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
11210         int err;
11211
11212         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11213                                            alc882_ignore);
11214         if (err < 0)
11215                 return err;
11216         if (!spec->autocfg.line_outs)
11217                 return 0; /* can't find valid BIOS pin config */
11218
11219         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
11220         if (err < 0)
11221                 return err;
11222         err = alc_auto_add_multi_channel_mode(codec);
11223         if (err < 0)
11224                 return err;
11225         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
11226         if (err < 0)
11227                 return err;
11228         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
11229                                            "Headphone");
11230         if (err < 0)
11231                 return err;
11232         err = alc880_auto_create_extra_out(spec,
11233                                            spec->autocfg.speaker_pins[0],
11234                                            "Speaker");
11235         if (err < 0)
11236                 return err;
11237         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
11238         if (err < 0)
11239                 return err;
11240
11241         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11242
11243         alc_auto_parse_digital(codec);
11244
11245         if (spec->kctls.list)
11246                 add_mixer(spec, spec->kctls.list);
11247
11248         add_verb(spec, alc883_auto_init_verbs);
11249         /* if ADC 0x07 is available, initialize it, too */
11250         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
11251                 add_verb(spec, alc882_adc1_init_verbs);
11252
11253         spec->num_mux_defs = 1;
11254         spec->input_mux = &spec->private_imux[0];
11255
11256         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11257
11258         err = alc_auto_add_mic_boost(codec);
11259         if (err < 0)
11260                 return err;
11261
11262         return 1; /* config found */
11263 }
11264
11265 /* additional initialization for auto-configuration model */
11266 static void alc882_auto_init(struct hda_codec *codec)
11267 {
11268         struct alc_spec *spec = codec->spec;
11269         alc882_auto_init_multi_out(codec);
11270         alc882_auto_init_hp_out(codec);
11271         alc882_auto_init_analog_input(codec);
11272         alc882_auto_init_input_src(codec);
11273         alc_auto_init_digital(codec);
11274         if (spec->unsol_event)
11275                 alc_inithook(codec);
11276 }
11277
11278 static int patch_alc882(struct hda_codec *codec)
11279 {
11280         struct alc_spec *spec;
11281         int err, board_config;
11282
11283         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11284         if (spec == NULL)
11285                 return -ENOMEM;
11286
11287         codec->spec = spec;
11288
11289         switch (codec->vendor_id) {
11290         case 0x10ec0882:
11291         case 0x10ec0885:
11292                 break;
11293         default:
11294                 /* ALC883 and variants */
11295                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11296                 break;
11297         }
11298
11299         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
11300                                                   alc882_models,
11301                                                   alc882_cfg_tbl);
11302
11303         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
11304                 board_config = snd_hda_check_board_codec_sid_config(codec,
11305                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
11306
11307         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
11308                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11309                        codec->chip_name);
11310                 board_config = ALC882_AUTO;
11311         }
11312
11313         if (board_config == ALC882_AUTO) {
11314                 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
11315                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
11316         }
11317
11318         alc_auto_parse_customize_define(codec);
11319
11320         if (board_config == ALC882_AUTO) {
11321                 /* automatic parse from the BIOS config */
11322                 err = alc882_parse_auto_config(codec);
11323                 if (err < 0) {
11324                         alc_free(codec);
11325                         return err;
11326                 } else if (!err) {
11327                         printk(KERN_INFO
11328                                "hda_codec: Cannot set up configuration "
11329                                "from BIOS.  Using base mode...\n");
11330                         board_config = ALC882_3ST_DIG;
11331                 }
11332         }
11333
11334         if (has_cdefine_beep(codec)) {
11335                 err = snd_hda_attach_beep_device(codec, 0x1);
11336                 if (err < 0) {
11337                         alc_free(codec);
11338                         return err;
11339                 }
11340         }
11341
11342         if (board_config != ALC882_AUTO)
11343                 setup_preset(codec, &alc882_presets[board_config]);
11344
11345         spec->stream_analog_playback = &alc882_pcm_analog_playback;
11346         spec->stream_analog_capture = &alc882_pcm_analog_capture;
11347         /* FIXME: setup DAC5 */
11348         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11349         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11350
11351         spec->stream_digital_playback = &alc882_pcm_digital_playback;
11352         spec->stream_digital_capture = &alc882_pcm_digital_capture;
11353
11354         if (!spec->adc_nids && spec->input_mux) {
11355                 int i, j;
11356                 spec->num_adc_nids = 0;
11357                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11358                         const struct hda_input_mux *imux = spec->input_mux;
11359                         hda_nid_t cap;
11360                         hda_nid_t items[16];
11361                         hda_nid_t nid = alc882_adc_nids[i];
11362                         unsigned int wcap = get_wcaps(codec, nid);
11363                         /* get type */
11364                         wcap = get_wcaps_type(wcap);
11365                         if (wcap != AC_WID_AUD_IN)
11366                                 continue;
11367                         spec->private_adc_nids[spec->num_adc_nids] = nid;
11368                         err = snd_hda_get_connections(codec, nid, &cap, 1);
11369                         if (err < 0)
11370                                 continue;
11371                         err = snd_hda_get_connections(codec, cap, items,
11372                                                       ARRAY_SIZE(items));
11373                         if (err < 0)
11374                                 continue;
11375                         for (j = 0; j < imux->num_items; j++)
11376                                 if (imux->items[j].index >= err)
11377                                         break;
11378                         if (j < imux->num_items)
11379                                 continue;
11380                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11381                         spec->num_adc_nids++;
11382                 }
11383                 spec->adc_nids = spec->private_adc_nids;
11384                 spec->capsrc_nids = spec->private_capsrc_nids;
11385         }
11386
11387         set_capture_mixer(codec);
11388
11389         if (has_cdefine_beep(codec))
11390                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11391
11392         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
11393
11394         spec->vmaster_nid = 0x0c;
11395
11396         codec->patch_ops = alc_patch_ops;
11397         if (board_config == ALC882_AUTO)
11398                 spec->init_hook = alc882_auto_init;
11399
11400         alc_init_jacks(codec);
11401 #ifdef CONFIG_SND_HDA_POWER_SAVE
11402         if (!spec->loopback.amplist)
11403                 spec->loopback.amplist = alc882_loopbacks;
11404 #endif
11405
11406         return 0;
11407 }
11408
11409
11410 /*
11411  * ALC262 support
11412  */
11413
11414 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
11415 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
11416
11417 #define alc262_dac_nids         alc260_dac_nids
11418 #define alc262_adc_nids         alc882_adc_nids
11419 #define alc262_adc_nids_alt     alc882_adc_nids_alt
11420 #define alc262_capsrc_nids      alc882_capsrc_nids
11421 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
11422
11423 #define alc262_modes            alc260_modes
11424 #define alc262_capture_source   alc882_capture_source
11425
11426 static const hda_nid_t alc262_dmic_adc_nids[1] = {
11427         /* ADC0 */
11428         0x09
11429 };
11430
11431 static const hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11432
11433 static const struct snd_kcontrol_new alc262_base_mixer[] = {
11434         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11435         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11436         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11437         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11438         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11439         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11440         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11441         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11442         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11443         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11444         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11445         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11446         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11447         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11448         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11449         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11450         { } /* end */
11451 };
11452
11453 /* update HP, line and mono-out pins according to the master switch */
11454 #define alc262_hp_master_update         alc260_hp_master_update
11455
11456 static void alc262_hp_bpc_setup(struct hda_codec *codec)
11457 {
11458         struct alc_spec *spec = codec->spec;
11459
11460         spec->autocfg.hp_pins[0] = 0x1b;
11461         spec->autocfg.speaker_pins[0] = 0x16;
11462         spec->automute = 1;
11463         spec->automute_mode = ALC_AUTOMUTE_PIN;
11464 }
11465
11466 static void alc262_hp_wildwest_setup(struct hda_codec *codec)
11467 {
11468         struct alc_spec *spec = codec->spec;
11469
11470         spec->autocfg.hp_pins[0] = 0x15;
11471         spec->autocfg.speaker_pins[0] = 0x16;
11472         spec->automute = 1;
11473         spec->automute_mode = ALC_AUTOMUTE_PIN;
11474 }
11475
11476 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11477 #define alc262_hp_master_sw_put         alc260_hp_master_sw_put
11478
11479 #define ALC262_HP_MASTER_SWITCH                                 \
11480         {                                                       \
11481                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11482                 .name = "Master Playback Switch",               \
11483                 .info = snd_ctl_boolean_mono_info,              \
11484                 .get = alc262_hp_master_sw_get,                 \
11485                 .put = alc262_hp_master_sw_put,                 \
11486         }, \
11487         {                                                       \
11488                 .iface = NID_MAPPING,                           \
11489                 .name = "Master Playback Switch",               \
11490                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11491         }
11492
11493
11494 static const struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11495         ALC262_HP_MASTER_SWITCH,
11496         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11497         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11498         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11499         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11500                               HDA_OUTPUT),
11501         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11502                             HDA_OUTPUT),
11503         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11504         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11505         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11506         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11507         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11508         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11509         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11510         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11511         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11512         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11513         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11514         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11515         { } /* end */
11516 };
11517
11518 static const struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11519         ALC262_HP_MASTER_SWITCH,
11520         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11521         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11522         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11523         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11524         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11525                               HDA_OUTPUT),
11526         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11527                             HDA_OUTPUT),
11528         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11529         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11530         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT),
11531         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11532         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11533         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11534         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11535         { } /* end */
11536 };
11537
11538 static const struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11539         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11540         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11541         HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT),
11542         { } /* end */
11543 };
11544
11545 /* mute/unmute internal speaker according to the hp jack and mute state */
11546 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11547 {
11548         struct alc_spec *spec = codec->spec;
11549
11550         spec->autocfg.hp_pins[0] = 0x15;
11551         spec->autocfg.speaker_pins[0] = 0x14;
11552         spec->automute = 1;
11553         spec->automute_mode = ALC_AUTOMUTE_PIN;
11554 }
11555
11556 static const struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11557         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11558         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11559         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11560         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11561         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11562         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11563         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11564         { } /* end */
11565 };
11566
11567 static const struct hda_verb alc262_hp_t5735_verbs[] = {
11568         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11569         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11570
11571         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11572         { }
11573 };
11574
11575 static const struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11576         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11577         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11578         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11579         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11580         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11581         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11582         { } /* end */
11583 };
11584
11585 static const struct hda_verb alc262_hp_rp5700_verbs[] = {
11586         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11587         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11588         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11589         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11590         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11591         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11592         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11593         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11594         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11595         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11596         {}
11597 };
11598
11599 static const struct hda_input_mux alc262_hp_rp5700_capture_source = {
11600         .num_items = 1,
11601         .items = {
11602                 { "Line", 0x1 },
11603         },
11604 };
11605
11606 /* bind hp and internal speaker mute (with plug check) as master switch */
11607 #define alc262_hippo_master_update      alc262_hp_master_update
11608 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11609 #define alc262_hippo_master_sw_put      alc262_hp_master_sw_put
11610
11611 #define ALC262_HIPPO_MASTER_SWITCH                              \
11612         {                                                       \
11613                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11614                 .name = "Master Playback Switch",               \
11615                 .info = snd_ctl_boolean_mono_info,              \
11616                 .get = alc262_hippo_master_sw_get,              \
11617                 .put = alc262_hippo_master_sw_put,              \
11618         },                                                      \
11619         {                                                       \
11620                 .iface = NID_MAPPING,                           \
11621                 .name = "Master Playback Switch",               \
11622                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11623                              (SUBDEV_SPEAKER(0) << 16), \
11624         }
11625
11626 static const struct snd_kcontrol_new alc262_hippo_mixer[] = {
11627         ALC262_HIPPO_MASTER_SWITCH,
11628         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11629         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11630         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11631         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11632         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11633         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11634         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11635         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11636         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11637         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11638         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11639         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11640         { } /* end */
11641 };
11642
11643 static const struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11644         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11645         ALC262_HIPPO_MASTER_SWITCH,
11646         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11647         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11648         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11649         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11650         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11651         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11652         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11653         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11654         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11655         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11656         { } /* end */
11657 };
11658
11659 /* mute/unmute internal speaker according to the hp jack and mute state */
11660 static void alc262_hippo_setup(struct hda_codec *codec)
11661 {
11662         struct alc_spec *spec = codec->spec;
11663
11664         spec->autocfg.hp_pins[0] = 0x15;
11665         spec->autocfg.speaker_pins[0] = 0x14;
11666         spec->automute = 1;
11667         spec->automute_mode = ALC_AUTOMUTE_AMP;
11668 }
11669
11670 static void alc262_hippo1_setup(struct hda_codec *codec)
11671 {
11672         struct alc_spec *spec = codec->spec;
11673
11674         spec->autocfg.hp_pins[0] = 0x1b;
11675         spec->autocfg.speaker_pins[0] = 0x14;
11676         spec->automute = 1;
11677         spec->automute_mode = ALC_AUTOMUTE_AMP;
11678 }
11679
11680
11681 static const struct snd_kcontrol_new alc262_sony_mixer[] = {
11682         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11683         ALC262_HIPPO_MASTER_SWITCH,
11684         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11685         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11686         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11687         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11688         { } /* end */
11689 };
11690
11691 static const struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11692         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11693         ALC262_HIPPO_MASTER_SWITCH,
11694         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11695         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11696         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11697         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11698         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11699         { } /* end */
11700 };
11701
11702 static const struct snd_kcontrol_new alc262_tyan_mixer[] = {
11703         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11704         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11705         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11706         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11707         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11708         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11709         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11710         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11711         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11712         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11713         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11714         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11715         { } /* end */
11716 };
11717
11718 static const struct hda_verb alc262_tyan_verbs[] = {
11719         /* Headphone automute */
11720         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11721         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11722         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11723
11724         /* P11 AUX_IN, white 4-pin connector */
11725         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11726         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11727         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11728         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11729
11730         {}
11731 };
11732
11733 /* unsolicited event for HP jack sensing */
11734 static void alc262_tyan_setup(struct hda_codec *codec)
11735 {
11736         struct alc_spec *spec = codec->spec;
11737
11738         spec->autocfg.hp_pins[0] = 0x1b;
11739         spec->autocfg.speaker_pins[0] = 0x15;
11740         spec->automute = 1;
11741         spec->automute_mode = ALC_AUTOMUTE_AMP;
11742 }
11743
11744
11745 #define alc262_capture_mixer            alc882_capture_mixer
11746 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11747
11748 /*
11749  * generic initialization of ADC, input mixers and output mixers
11750  */
11751 static const struct hda_verb alc262_init_verbs[] = {
11752         /*
11753          * Unmute ADC0-2 and set the default input to mic-in
11754          */
11755         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11756         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11757         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11758         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11759         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11760         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11761
11762         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11763          * mixer widget
11764          * Note: PASD motherboards uses the Line In 2 as the input for
11765          * front panel mic (mic 2)
11766          */
11767         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11768         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11769         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11770         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11771         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11772         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11773
11774         /*
11775          * Set up output mixers (0x0c - 0x0e)
11776          */
11777         /* set vol=0 to output mixers */
11778         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11779         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11780         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11781         /* set up input amps for analog loopback */
11782         /* Amp Indices: DAC = 0, mixer = 1 */
11783         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11784         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11785         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11786         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11787         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11788         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11789
11790         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11791         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11792         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11793         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11794         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11795         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11796
11797         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11798         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11799         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11800         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11801         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11802
11803         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11804         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11805
11806         /* FIXME: use matrix-type input source selection */
11807         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11808         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11809         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11810         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11811         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11812         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11813         /* Input mixer2 */
11814         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11815         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11816         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11817         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11818         /* Input mixer3 */
11819         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11820         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11821         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11822         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11823
11824         { }
11825 };
11826
11827 static const struct hda_verb alc262_eapd_verbs[] = {
11828         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11829         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11830         { }
11831 };
11832
11833 static const struct hda_verb alc262_hippo1_unsol_verbs[] = {
11834         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11835         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11836         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11837
11838         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11839         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11840         {}
11841 };
11842
11843 static const struct hda_verb alc262_sony_unsol_verbs[] = {
11844         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11845         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11846         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11847
11848         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11849         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11850         {}
11851 };
11852
11853 static const struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11854         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11855         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11856         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11857         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11858         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11859         { } /* end */
11860 };
11861
11862 static const struct hda_verb alc262_toshiba_s06_verbs[] = {
11863         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11864         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11865         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11866         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11867         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11868         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11869         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11870         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11871         {}
11872 };
11873
11874 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11875 {
11876         struct alc_spec *spec = codec->spec;
11877
11878         spec->autocfg.hp_pins[0] = 0x15;
11879         spec->autocfg.speaker_pins[0] = 0x14;
11880         spec->ext_mic.pin = 0x18;
11881         spec->ext_mic.mux_idx = 0;
11882         spec->int_mic.pin = 0x12;
11883         spec->int_mic.mux_idx = 9;
11884         spec->auto_mic = 1;
11885         spec->automute = 1;
11886         spec->automute_mode = ALC_AUTOMUTE_PIN;
11887 }
11888
11889 /*
11890  * nec model
11891  *  0x15 = headphone
11892  *  0x16 = internal speaker
11893  *  0x18 = external mic
11894  */
11895
11896 static const struct snd_kcontrol_new alc262_nec_mixer[] = {
11897         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11898         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11899
11900         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11901         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11902         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11903
11904         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11905         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11906         { } /* end */
11907 };
11908
11909 static const struct hda_verb alc262_nec_verbs[] = {
11910         /* Unmute Speaker */
11911         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11912
11913         /* Headphone */
11914         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11915         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11916
11917         /* External mic to headphone */
11918         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11919         /* External mic to speaker */
11920         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11921         {}
11922 };
11923
11924 /*
11925  * fujitsu model
11926  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11927  *  0x1b = port replicator headphone out
11928  */
11929
11930 #define ALC_HP_EVENT    ALC880_HP_EVENT
11931
11932 static const struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11933         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11934         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11935         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11936         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11937         {}
11938 };
11939
11940 static const struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11941         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11942         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11943         {}
11944 };
11945
11946 static const struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11947         /* Front Mic pin: input vref at 50% */
11948         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11949         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11950         {}
11951 };
11952
11953 static const struct hda_input_mux alc262_fujitsu_capture_source = {
11954         .num_items = 3,
11955         .items = {
11956                 { "Mic", 0x0 },
11957                 { "Internal Mic", 0x1 },
11958                 { "CD", 0x4 },
11959         },
11960 };
11961
11962 static const struct hda_input_mux alc262_HP_capture_source = {
11963         .num_items = 5,
11964         .items = {
11965                 { "Mic", 0x0 },
11966                 { "Front Mic", 0x1 },
11967                 { "Line", 0x2 },
11968                 { "CD", 0x4 },
11969                 { "AUX IN", 0x6 },
11970         },
11971 };
11972
11973 static const struct hda_input_mux alc262_HP_D7000_capture_source = {
11974         .num_items = 4,
11975         .items = {
11976                 { "Mic", 0x0 },
11977                 { "Front Mic", 0x2 },
11978                 { "Line", 0x1 },
11979                 { "CD", 0x4 },
11980         },
11981 };
11982
11983 static void alc262_fujitsu_setup(struct hda_codec *codec)
11984 {
11985         struct alc_spec *spec = codec->spec;
11986
11987         spec->autocfg.hp_pins[0] = 0x14;
11988         spec->autocfg.hp_pins[1] = 0x1b;
11989         spec->autocfg.speaker_pins[0] = 0x15;
11990         spec->automute = 1;
11991         spec->automute_mode = ALC_AUTOMUTE_AMP;
11992 }
11993
11994 /* bind volumes of both NID 0x0c and 0x0d */
11995 static const struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11996         .ops = &snd_hda_bind_vol,
11997         .values = {
11998                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11999                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
12000                 0
12001         },
12002 };
12003
12004 static const struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
12005         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12006         {
12007                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12008                 .name = "Master Playback Switch",
12009                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
12010                 .info = snd_ctl_boolean_mono_info,
12011                 .get = alc262_hp_master_sw_get,
12012                 .put = alc262_hp_master_sw_put,
12013         },
12014         {
12015                 .iface = NID_MAPPING,
12016                 .name = "Master Playback Switch",
12017                 .private_value = 0x1b,
12018         },
12019         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12020         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12021         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12022         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12023         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12024         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
12025         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12026         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12027         { } /* end */
12028 };
12029
12030 static void alc262_lenovo_3000_setup(struct hda_codec *codec)
12031 {
12032         struct alc_spec *spec = codec->spec;
12033
12034         spec->autocfg.hp_pins[0] = 0x1b;
12035         spec->autocfg.speaker_pins[0] = 0x14;
12036         spec->autocfg.speaker_pins[1] = 0x16;
12037         spec->automute = 1;
12038         spec->automute_mode = ALC_AUTOMUTE_AMP;
12039 }
12040
12041 static const struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
12042         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12043         {
12044                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12045                 .name = "Master Playback Switch",
12046                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
12047                 .info = snd_ctl_boolean_mono_info,
12048                 .get = alc262_hp_master_sw_get,
12049                 .put = alc262_hp_master_sw_put,
12050         },
12051         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12052         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12053         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12054         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12055         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12056         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
12057         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12058         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12059         { } /* end */
12060 };
12061
12062 static const struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
12063         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12064         ALC262_HIPPO_MASTER_SWITCH,
12065         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12066         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12067         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12068         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12069         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12070         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
12071         { } /* end */
12072 };
12073
12074 /* additional init verbs for Benq laptops */
12075 static const struct hda_verb alc262_EAPD_verbs[] = {
12076         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
12077         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
12078         {}
12079 };
12080
12081 static const struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
12082         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12083         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12084
12085         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
12086         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
12087         {}
12088 };
12089
12090 /* Samsung Q1 Ultra Vista model setup */
12091 static const struct snd_kcontrol_new alc262_ultra_mixer[] = {
12092         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
12093         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
12094         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12095         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12096         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
12097         HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
12098         { } /* end */
12099 };
12100
12101 static const struct hda_verb alc262_ultra_verbs[] = {
12102         /* output mixer */
12103         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12104         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12105         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12106         /* speaker */
12107         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12108         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12109         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12110         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12111         /* HP */
12112         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12113         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12114         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12115         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12116         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12117         /* internal mic */
12118         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12119         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12120         /* ADC, choose mic */
12121         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12122         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12123         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12124         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12125         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12126         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12127         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12128         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12129         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12130         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
12131         {}
12132 };
12133
12134 /* mute/unmute internal speaker according to the hp jack and mute state */
12135 static void alc262_ultra_automute(struct hda_codec *codec)
12136 {
12137         struct alc_spec *spec = codec->spec;
12138         unsigned int mute;
12139
12140         mute = 0;
12141         /* auto-mute only when HP is used as HP */
12142         if (!spec->cur_mux[0]) {
12143                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
12144                 if (spec->jack_present)
12145                         mute = HDA_AMP_MUTE;
12146         }
12147         /* mute/unmute internal speaker */
12148         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12149                                  HDA_AMP_MUTE, mute);
12150         /* mute/unmute HP */
12151         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12152                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
12153 }
12154
12155 /* unsolicited event for HP jack sensing */
12156 static void alc262_ultra_unsol_event(struct hda_codec *codec,
12157                                        unsigned int res)
12158 {
12159         if ((res >> 26) != ALC880_HP_EVENT)
12160                 return;
12161         alc262_ultra_automute(codec);
12162 }
12163
12164 static const struct hda_input_mux alc262_ultra_capture_source = {
12165         .num_items = 2,
12166         .items = {
12167                 { "Mic", 0x1 },
12168                 { "Headphone", 0x7 },
12169         },
12170 };
12171
12172 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
12173                                      struct snd_ctl_elem_value *ucontrol)
12174 {
12175         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12176         struct alc_spec *spec = codec->spec;
12177         int ret;
12178
12179         ret = alc_mux_enum_put(kcontrol, ucontrol);
12180         if (!ret)
12181                 return 0;
12182         /* reprogram the HP pin as mic or HP according to the input source */
12183         snd_hda_codec_write_cache(codec, 0x15, 0,
12184                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
12185                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12186         alc262_ultra_automute(codec); /* mute/unmute HP */
12187         return ret;
12188 }
12189
12190 static const struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12191         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12192         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12193         {
12194                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12195                 .name = "Capture Source",
12196                 .info = alc_mux_enum_info,
12197                 .get = alc_mux_enum_get,
12198                 .put = alc262_ultra_mux_enum_put,
12199         },
12200         {
12201                 .iface = NID_MAPPING,
12202                 .name = "Capture Source",
12203                 .private_value = 0x15,
12204         },
12205         { } /* end */
12206 };
12207
12208 /* We use two mixers depending on the output pin; 0x16 is a mono output
12209  * and thus it's bound with a different mixer.
12210  * This function returns which mixer amp should be used.
12211  */
12212 static int alc262_check_volbit(hda_nid_t nid)
12213 {
12214         if (!nid)
12215                 return 0;
12216         else if (nid == 0x16)
12217                 return 2;
12218         else
12219                 return 1;
12220 }
12221
12222 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12223                                   const char *pfx, int *vbits, int idx)
12224 {
12225         unsigned long val;
12226         int vbit;
12227
12228         vbit = alc262_check_volbit(nid);
12229         if (!vbit)
12230                 return 0;
12231         if (*vbits & vbit) /* a volume control for this mixer already there */
12232                 return 0;
12233         *vbits |= vbit;
12234         if (vbit == 2)
12235                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12236         else
12237                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12238         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12239 }
12240
12241 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12242                                  const char *pfx, int idx)
12243 {
12244         unsigned long val;
12245
12246         if (!nid)
12247                 return 0;
12248         if (nid == 0x16)
12249                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12250         else
12251                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12252         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12253 }
12254
12255 /* add playback controls from the parsed DAC table */
12256 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12257                                              const struct auto_pin_cfg *cfg)
12258 {
12259         const char *pfx;
12260         int vbits;
12261         int i, index, err;
12262
12263         spec->multiout.num_dacs = 1;    /* only use one dac */
12264         spec->multiout.dac_nids = spec->private_dac_nids;
12265         spec->private_dac_nids[0] = 2;
12266
12267         for (i = 0; i < 2; i++) {
12268                 pfx = alc_get_line_out_pfx(spec, i, true, &index);
12269                 if (!pfx)
12270                         pfx = "PCM";
12271                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx,
12272                                             index);
12273                 if (err < 0)
12274                         return err;
12275                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12276                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12277                                                     "Speaker", i);
12278                         if (err < 0)
12279                                 return err;
12280                 }
12281                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12282                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12283                                                     "Headphone", i);
12284                         if (err < 0)
12285                                 return err;
12286                 }
12287         }
12288
12289         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12290                 alc262_check_volbit(cfg->speaker_pins[0]) |
12291                 alc262_check_volbit(cfg->hp_pins[0]);
12292         vbits = 0;
12293         for (i = 0; i < 2; i++) {
12294                 pfx = alc_get_line_out_pfx(spec, i, true, &index);
12295                 if (!pfx)
12296                         pfx = "PCM";
12297                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12298                                              &vbits, i);
12299                 if (err < 0)
12300                         return err;
12301                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12302                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12303                                                      "Speaker", &vbits, i);
12304                         if (err < 0)
12305                                 return err;
12306                 }
12307                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12308                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12309                                                      "Headphone", &vbits, i);
12310                         if (err < 0)
12311                                 return err;
12312                 }
12313         }
12314         return 0;
12315 }
12316
12317 #define alc262_auto_create_input_ctls \
12318         alc882_auto_create_input_ctls
12319
12320 /*
12321  * generic initialization of ADC, input mixers and output mixers
12322  */
12323 static const struct hda_verb alc262_volume_init_verbs[] = {
12324         /*
12325          * Unmute ADC0-2 and set the default input to mic-in
12326          */
12327         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12328         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12329         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12330         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12331         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12332         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12333
12334         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12335          * mixer widget
12336          * Note: PASD motherboards uses the Line In 2 as the input for
12337          * front panel mic (mic 2)
12338          */
12339         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12340         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12341         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12342         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12343         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12344         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12345
12346         /*
12347          * Set up output mixers (0x0c - 0x0f)
12348          */
12349         /* set vol=0 to output mixers */
12350         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12351         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12352         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12353
12354         /* set up input amps for analog loopback */
12355         /* Amp Indices: DAC = 0, mixer = 1 */
12356         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12357         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12358         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12359         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12360         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12361         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12362
12363         /* FIXME: use matrix-type input source selection */
12364         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12365         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12366         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12367         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12368         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12369         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12370         /* Input mixer2 */
12371         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12372         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12373         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12374         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12375         /* Input mixer3 */
12376         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12377         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12378         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12379         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12380
12381         { }
12382 };
12383
12384 static const struct hda_verb alc262_HP_BPC_init_verbs[] = {
12385         /*
12386          * Unmute ADC0-2 and set the default input to mic-in
12387          */
12388         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12389         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12390         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12391         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12392         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12393         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12394
12395         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12396          * mixer widget
12397          * Note: PASD motherboards uses the Line In 2 as the input for
12398          * front panel mic (mic 2)
12399          */
12400         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12401         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12402         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12403         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12404         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12405         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12406         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12407         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12408
12409         /*
12410          * Set up output mixers (0x0c - 0x0e)
12411          */
12412         /* set vol=0 to output mixers */
12413         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12414         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12415         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12416
12417         /* set up input amps for analog loopback */
12418         /* Amp Indices: DAC = 0, mixer = 1 */
12419         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12420         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12421         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12422         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12423         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12424         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12425
12426         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12427         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12428         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12429
12430         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12431         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12432
12433         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12434         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12435
12436         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12437         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12438         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12439         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12440         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12441
12442         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12443         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12444         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12445         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12446         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12447         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12448
12449
12450         /* FIXME: use matrix-type input source selection */
12451         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12452         /* Input mixer1: only unmute Mic */
12453         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12454         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12455         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12456         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12457         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12458         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12459         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12460         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12461         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12462         /* Input mixer2 */
12463         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12464         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12465         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12466         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12467         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12468         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12469         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12470         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12471         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12472         /* Input mixer3 */
12473         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12474         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12475         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12476         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12477         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12478         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12479         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12480         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12481         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12482
12483         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12484
12485         { }
12486 };
12487
12488 static const struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12489         /*
12490          * Unmute ADC0-2 and set the default input to mic-in
12491          */
12492         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12493         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12494         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12495         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12496         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12497         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12498
12499         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12500          * mixer widget
12501          * Note: PASD motherboards uses the Line In 2 as the input for front
12502          * panel mic (mic 2)
12503          */
12504         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12505         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12506         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12507         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12508         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12509         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12510         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12511         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12512         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12513         /*
12514          * Set up output mixers (0x0c - 0x0e)
12515          */
12516         /* set vol=0 to output mixers */
12517         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12518         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12519         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12520
12521         /* set up input amps for analog loopback */
12522         /* Amp Indices: DAC = 0, mixer = 1 */
12523         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12524         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12525         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12526         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12527         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12528         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12529
12530
12531         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12532         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12533         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12534         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12535         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12536         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12537         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12538
12539         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12540         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12541
12542         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12543         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12544
12545         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12546         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12547         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12548         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12549         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12550         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12551
12552         /* FIXME: use matrix-type input source selection */
12553         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12554         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12555         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12556         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12557         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12558         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12559         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12560         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12561         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12562         /* Input mixer2 */
12563         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12564         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12565         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12566         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12567         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12568         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12569         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12570         /* Input mixer3 */
12571         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12572         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12573         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12574         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12575         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12576         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12577         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12578
12579         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12580
12581         { }
12582 };
12583
12584 static const struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12585
12586         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12587         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12588         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12589
12590         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12591         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12592         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12593         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12594
12595         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12596         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12597         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12598         {}
12599 };
12600
12601 /*
12602  * Pin config fixes
12603  */
12604 enum {
12605         PINFIX_FSC_H270,
12606         PINFIX_HP_Z200,
12607 };
12608
12609 static const struct alc_fixup alc262_fixups[] = {
12610         [PINFIX_FSC_H270] = {
12611                 .type = ALC_FIXUP_PINS,
12612                 .v.pins = (const struct alc_pincfg[]) {
12613                         { 0x14, 0x99130110 }, /* speaker */
12614                         { 0x15, 0x0221142f }, /* front HP */
12615                         { 0x1b, 0x0121141f }, /* rear HP */
12616                         { }
12617                 }
12618         },
12619         [PINFIX_HP_Z200] = {
12620                 .type = ALC_FIXUP_PINS,
12621                 .v.pins = (const struct alc_pincfg[]) {
12622                         { 0x16, 0x99130120 }, /* internal speaker */
12623                         { }
12624                 }
12625         },
12626 };
12627
12628 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
12629         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
12630         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12631         {}
12632 };
12633
12634
12635 #ifdef CONFIG_SND_HDA_POWER_SAVE
12636 #define alc262_loopbacks        alc880_loopbacks
12637 #endif
12638
12639 /* pcm configuration: identical with ALC880 */
12640 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12641 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12642 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12643 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12644
12645 /*
12646  * BIOS auto configuration
12647  */
12648 static int alc262_parse_auto_config(struct hda_codec *codec)
12649 {
12650         struct alc_spec *spec = codec->spec;
12651         int err;
12652         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12653
12654         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12655                                            alc262_ignore);
12656         if (err < 0)
12657                 return err;
12658         if (!spec->autocfg.line_outs) {
12659                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12660                         spec->multiout.max_channels = 2;
12661                         spec->no_analog = 1;
12662                         goto dig_only;
12663                 }
12664                 return 0; /* can't find valid BIOS pin config */
12665         }
12666         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12667         if (err < 0)
12668                 return err;
12669         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12670         if (err < 0)
12671                 return err;
12672
12673         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12674
12675  dig_only:
12676         alc_auto_parse_digital(codec);
12677
12678         if (spec->kctls.list)
12679                 add_mixer(spec, spec->kctls.list);
12680
12681         add_verb(spec, alc262_volume_init_verbs);
12682         spec->num_mux_defs = 1;
12683         spec->input_mux = &spec->private_imux[0];
12684
12685         err = alc_auto_add_mic_boost(codec);
12686         if (err < 0)
12687                 return err;
12688
12689         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12690
12691         return 1;
12692 }
12693
12694 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12695 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12696 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12697 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12698
12699
12700 /* init callback for auto-configuration model -- overriding the default init */
12701 static void alc262_auto_init(struct hda_codec *codec)
12702 {
12703         struct alc_spec *spec = codec->spec;
12704         alc262_auto_init_multi_out(codec);
12705         alc262_auto_init_hp_out(codec);
12706         alc262_auto_init_analog_input(codec);
12707         alc262_auto_init_input_src(codec);
12708         alc_auto_init_digital(codec);
12709         if (spec->unsol_event)
12710                 alc_inithook(codec);
12711 }
12712
12713 /*
12714  * configuration and preset
12715  */
12716 static const char * const alc262_models[ALC262_MODEL_LAST] = {
12717         [ALC262_BASIC]          = "basic",
12718         [ALC262_HIPPO]          = "hippo",
12719         [ALC262_HIPPO_1]        = "hippo_1",
12720         [ALC262_FUJITSU]        = "fujitsu",
12721         [ALC262_HP_BPC]         = "hp-bpc",
12722         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12723         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12724         [ALC262_HP_RP5700]      = "hp-rp5700",
12725         [ALC262_BENQ_ED8]       = "benq",
12726         [ALC262_BENQ_T31]       = "benq-t31",
12727         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12728         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12729         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12730         [ALC262_ULTRA]          = "ultra",
12731         [ALC262_LENOVO_3000]    = "lenovo-3000",
12732         [ALC262_NEC]            = "nec",
12733         [ALC262_TYAN]           = "tyan",
12734         [ALC262_AUTO]           = "auto",
12735 };
12736
12737 static const struct snd_pci_quirk alc262_cfg_tbl[] = {
12738         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12739         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12740         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12741                            ALC262_HP_BPC),
12742         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12743                            ALC262_HP_BPC),
12744         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1500, "HP z series",
12745                            ALC262_HP_BPC),
12746         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200",
12747                            ALC262_AUTO),
12748         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12749                            ALC262_HP_BPC),
12750         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12751         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12752         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12753         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12754         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12755         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12756         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12757         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12758         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12759         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12760         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12761         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12762                       ALC262_HP_TC_T5735),
12763         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12764         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12765         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12766         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12767         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12768         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12769         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12770         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12771 #if 0 /* disable the quirk since model=auto works better in recent versions */
12772         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12773                            ALC262_SONY_ASSAMD),
12774 #endif
12775         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12776                       ALC262_TOSHIBA_RX1),
12777         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12778         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12779         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12780         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12781         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12782                            ALC262_ULTRA),
12783         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12784         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12785         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12786         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12787         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12788         {}
12789 };
12790
12791 static const struct alc_config_preset alc262_presets[] = {
12792         [ALC262_BASIC] = {
12793                 .mixers = { alc262_base_mixer },
12794                 .init_verbs = { alc262_init_verbs },
12795                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12796                 .dac_nids = alc262_dac_nids,
12797                 .hp_nid = 0x03,
12798                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12799                 .channel_mode = alc262_modes,
12800                 .input_mux = &alc262_capture_source,
12801         },
12802         [ALC262_HIPPO] = {
12803                 .mixers = { alc262_hippo_mixer },
12804                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12805                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12806                 .dac_nids = alc262_dac_nids,
12807                 .hp_nid = 0x03,
12808                 .dig_out_nid = ALC262_DIGOUT_NID,
12809                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12810                 .channel_mode = alc262_modes,
12811                 .input_mux = &alc262_capture_source,
12812                 .unsol_event = alc_sku_unsol_event,
12813                 .setup = alc262_hippo_setup,
12814                 .init_hook = alc_inithook,
12815         },
12816         [ALC262_HIPPO_1] = {
12817                 .mixers = { alc262_hippo1_mixer },
12818                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12819                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12820                 .dac_nids = alc262_dac_nids,
12821                 .hp_nid = 0x02,
12822                 .dig_out_nid = ALC262_DIGOUT_NID,
12823                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12824                 .channel_mode = alc262_modes,
12825                 .input_mux = &alc262_capture_source,
12826                 .unsol_event = alc_sku_unsol_event,
12827                 .setup = alc262_hippo1_setup,
12828                 .init_hook = alc_inithook,
12829         },
12830         [ALC262_FUJITSU] = {
12831                 .mixers = { alc262_fujitsu_mixer },
12832                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12833                                 alc262_fujitsu_unsol_verbs },
12834                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12835                 .dac_nids = alc262_dac_nids,
12836                 .hp_nid = 0x03,
12837                 .dig_out_nid = ALC262_DIGOUT_NID,
12838                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12839                 .channel_mode = alc262_modes,
12840                 .input_mux = &alc262_fujitsu_capture_source,
12841                 .unsol_event = alc_sku_unsol_event,
12842                 .setup = alc262_fujitsu_setup,
12843                 .init_hook = alc_inithook,
12844         },
12845         [ALC262_HP_BPC] = {
12846                 .mixers = { alc262_HP_BPC_mixer },
12847                 .init_verbs = { alc262_HP_BPC_init_verbs },
12848                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12849                 .dac_nids = alc262_dac_nids,
12850                 .hp_nid = 0x03,
12851                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12852                 .channel_mode = alc262_modes,
12853                 .input_mux = &alc262_HP_capture_source,
12854                 .unsol_event = alc_sku_unsol_event,
12855                 .setup = alc262_hp_bpc_setup,
12856                 .init_hook = alc_inithook,
12857         },
12858         [ALC262_HP_BPC_D7000_WF] = {
12859                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12860                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12861                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12862                 .dac_nids = alc262_dac_nids,
12863                 .hp_nid = 0x03,
12864                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12865                 .channel_mode = alc262_modes,
12866                 .input_mux = &alc262_HP_D7000_capture_source,
12867                 .unsol_event = alc_sku_unsol_event,
12868                 .setup = alc262_hp_wildwest_setup,
12869                 .init_hook = alc_inithook,
12870         },
12871         [ALC262_HP_BPC_D7000_WL] = {
12872                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12873                             alc262_HP_BPC_WildWest_option_mixer },
12874                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12875                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12876                 .dac_nids = alc262_dac_nids,
12877                 .hp_nid = 0x03,
12878                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12879                 .channel_mode = alc262_modes,
12880                 .input_mux = &alc262_HP_D7000_capture_source,
12881                 .unsol_event = alc_sku_unsol_event,
12882                 .setup = alc262_hp_wildwest_setup,
12883                 .init_hook = alc_inithook,
12884         },
12885         [ALC262_HP_TC_T5735] = {
12886                 .mixers = { alc262_hp_t5735_mixer },
12887                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12888                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12889                 .dac_nids = alc262_dac_nids,
12890                 .hp_nid = 0x03,
12891                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12892                 .channel_mode = alc262_modes,
12893                 .input_mux = &alc262_capture_source,
12894                 .unsol_event = alc_sku_unsol_event,
12895                 .setup = alc262_hp_t5735_setup,
12896                 .init_hook = alc_inithook,
12897         },
12898         [ALC262_HP_RP5700] = {
12899                 .mixers = { alc262_hp_rp5700_mixer },
12900                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12901                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12902                 .dac_nids = alc262_dac_nids,
12903                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12904                 .channel_mode = alc262_modes,
12905                 .input_mux = &alc262_hp_rp5700_capture_source,
12906         },
12907         [ALC262_BENQ_ED8] = {
12908                 .mixers = { alc262_base_mixer },
12909                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12910                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12911                 .dac_nids = alc262_dac_nids,
12912                 .hp_nid = 0x03,
12913                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12914                 .channel_mode = alc262_modes,
12915                 .input_mux = &alc262_capture_source,
12916         },
12917         [ALC262_SONY_ASSAMD] = {
12918                 .mixers = { alc262_sony_mixer },
12919                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12920                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12921                 .dac_nids = alc262_dac_nids,
12922                 .hp_nid = 0x02,
12923                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12924                 .channel_mode = alc262_modes,
12925                 .input_mux = &alc262_capture_source,
12926                 .unsol_event = alc_sku_unsol_event,
12927                 .setup = alc262_hippo_setup,
12928                 .init_hook = alc_inithook,
12929         },
12930         [ALC262_BENQ_T31] = {
12931                 .mixers = { alc262_benq_t31_mixer },
12932                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12933                                 alc_hp15_unsol_verbs },
12934                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12935                 .dac_nids = alc262_dac_nids,
12936                 .hp_nid = 0x03,
12937                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12938                 .channel_mode = alc262_modes,
12939                 .input_mux = &alc262_capture_source,
12940                 .unsol_event = alc_sku_unsol_event,
12941                 .setup = alc262_hippo_setup,
12942                 .init_hook = alc_inithook,
12943         },
12944         [ALC262_ULTRA] = {
12945                 .mixers = { alc262_ultra_mixer },
12946                 .cap_mixer = alc262_ultra_capture_mixer,
12947                 .init_verbs = { alc262_ultra_verbs },
12948                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12949                 .dac_nids = alc262_dac_nids,
12950                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12951                 .channel_mode = alc262_modes,
12952                 .input_mux = &alc262_ultra_capture_source,
12953                 .adc_nids = alc262_adc_nids, /* ADC0 */
12954                 .capsrc_nids = alc262_capsrc_nids,
12955                 .num_adc_nids = 1, /* single ADC */
12956                 .unsol_event = alc262_ultra_unsol_event,
12957                 .init_hook = alc262_ultra_automute,
12958         },
12959         [ALC262_LENOVO_3000] = {
12960                 .mixers = { alc262_lenovo_3000_mixer },
12961                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12962                                 alc262_lenovo_3000_unsol_verbs,
12963                                 alc262_lenovo_3000_init_verbs },
12964                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12965                 .dac_nids = alc262_dac_nids,
12966                 .hp_nid = 0x03,
12967                 .dig_out_nid = ALC262_DIGOUT_NID,
12968                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12969                 .channel_mode = alc262_modes,
12970                 .input_mux = &alc262_fujitsu_capture_source,
12971                 .unsol_event = alc_sku_unsol_event,
12972                 .setup = alc262_lenovo_3000_setup,
12973                 .init_hook = alc_inithook,
12974         },
12975         [ALC262_NEC] = {
12976                 .mixers = { alc262_nec_mixer },
12977                 .init_verbs = { alc262_nec_verbs },
12978                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12979                 .dac_nids = alc262_dac_nids,
12980                 .hp_nid = 0x03,
12981                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12982                 .channel_mode = alc262_modes,
12983                 .input_mux = &alc262_capture_source,
12984         },
12985         [ALC262_TOSHIBA_S06] = {
12986                 .mixers = { alc262_toshiba_s06_mixer },
12987                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12988                                                         alc262_eapd_verbs },
12989                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12990                 .capsrc_nids = alc262_dmic_capsrc_nids,
12991                 .dac_nids = alc262_dac_nids,
12992                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12993                 .num_adc_nids = 1, /* single ADC */
12994                 .dig_out_nid = ALC262_DIGOUT_NID,
12995                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12996                 .channel_mode = alc262_modes,
12997                 .unsol_event = alc_sku_unsol_event,
12998                 .setup = alc262_toshiba_s06_setup,
12999                 .init_hook = alc_inithook,
13000         },
13001         [ALC262_TOSHIBA_RX1] = {
13002                 .mixers = { alc262_toshiba_rx1_mixer },
13003                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
13004                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
13005                 .dac_nids = alc262_dac_nids,
13006                 .hp_nid = 0x03,
13007                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
13008                 .channel_mode = alc262_modes,
13009                 .input_mux = &alc262_capture_source,
13010                 .unsol_event = alc_sku_unsol_event,
13011                 .setup = alc262_hippo_setup,
13012                 .init_hook = alc_inithook,
13013         },
13014         [ALC262_TYAN] = {
13015                 .mixers = { alc262_tyan_mixer },
13016                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
13017                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
13018                 .dac_nids = alc262_dac_nids,
13019                 .hp_nid = 0x02,
13020                 .dig_out_nid = ALC262_DIGOUT_NID,
13021                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
13022                 .channel_mode = alc262_modes,
13023                 .input_mux = &alc262_capture_source,
13024                 .unsol_event = alc_sku_unsol_event,
13025                 .setup = alc262_tyan_setup,
13026                 .init_hook = alc_hp_automute,
13027         },
13028 };
13029
13030 static int patch_alc262(struct hda_codec *codec)
13031 {
13032         struct alc_spec *spec;
13033         int board_config;
13034         int err;
13035
13036         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13037         if (spec == NULL)
13038                 return -ENOMEM;
13039
13040         codec->spec = spec;
13041 #if 0
13042         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
13043          * under-run
13044          */
13045         {
13046         int tmp;
13047         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
13048         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
13049         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
13050         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
13051         }
13052 #endif
13053         alc_auto_parse_customize_define(codec);
13054
13055         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
13056
13057         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
13058                                                   alc262_models,
13059                                                   alc262_cfg_tbl);
13060
13061         if (board_config < 0) {
13062                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13063                        codec->chip_name);
13064                 board_config = ALC262_AUTO;
13065         }
13066
13067         if (board_config == ALC262_AUTO) {
13068                 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
13069                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
13070         }
13071
13072         if (board_config == ALC262_AUTO) {
13073                 /* automatic parse from the BIOS config */
13074                 err = alc262_parse_auto_config(codec);
13075                 if (err < 0) {
13076                         alc_free(codec);
13077                         return err;
13078                 } else if (!err) {
13079                         printk(KERN_INFO
13080                                "hda_codec: Cannot set up configuration "
13081                                "from BIOS.  Using base mode...\n");
13082                         board_config = ALC262_BASIC;
13083                 }
13084         }
13085
13086         if (!spec->no_analog && has_cdefine_beep(codec)) {
13087                 err = snd_hda_attach_beep_device(codec, 0x1);
13088                 if (err < 0) {
13089                         alc_free(codec);
13090                         return err;
13091                 }
13092         }
13093
13094         if (board_config != ALC262_AUTO)
13095                 setup_preset(codec, &alc262_presets[board_config]);
13096
13097         spec->stream_analog_playback = &alc262_pcm_analog_playback;
13098         spec->stream_analog_capture = &alc262_pcm_analog_capture;
13099
13100         spec->stream_digital_playback = &alc262_pcm_digital_playback;
13101         spec->stream_digital_capture = &alc262_pcm_digital_capture;
13102
13103         if (!spec->adc_nids && spec->input_mux) {
13104                 int i;
13105                 /* check whether the digital-mic has to be supported */
13106                 for (i = 0; i < spec->input_mux->num_items; i++) {
13107                         if (spec->input_mux->items[i].index >= 9)
13108                                 break;
13109                 }
13110                 if (i < spec->input_mux->num_items) {
13111                         /* use only ADC0 */
13112                         spec->adc_nids = alc262_dmic_adc_nids;
13113                         spec->num_adc_nids = 1;
13114                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
13115                 } else {
13116                         /* all analog inputs */
13117                         /* check whether NID 0x07 is valid */
13118                         unsigned int wcap = get_wcaps(codec, 0x07);
13119
13120                         /* get type */
13121                         wcap = get_wcaps_type(wcap);
13122                         if (wcap != AC_WID_AUD_IN) {
13123                                 spec->adc_nids = alc262_adc_nids_alt;
13124                                 spec->num_adc_nids =
13125                                         ARRAY_SIZE(alc262_adc_nids_alt);
13126                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
13127                         } else {
13128                                 spec->adc_nids = alc262_adc_nids;
13129                                 spec->num_adc_nids =
13130                                         ARRAY_SIZE(alc262_adc_nids);
13131                                 spec->capsrc_nids = alc262_capsrc_nids;
13132                         }
13133                 }
13134         }
13135         if (!spec->cap_mixer && !spec->no_analog)
13136                 set_capture_mixer(codec);
13137         if (!spec->no_analog && has_cdefine_beep(codec))
13138                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13139
13140         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
13141
13142         spec->vmaster_nid = 0x0c;
13143
13144         codec->patch_ops = alc_patch_ops;
13145         if (board_config == ALC262_AUTO)
13146                 spec->init_hook = alc262_auto_init;
13147         spec->shutup = alc_eapd_shutup;
13148
13149         alc_init_jacks(codec);
13150 #ifdef CONFIG_SND_HDA_POWER_SAVE
13151         if (!spec->loopback.amplist)
13152                 spec->loopback.amplist = alc262_loopbacks;
13153 #endif
13154
13155         return 0;
13156 }
13157
13158 /*
13159  *  ALC268 channel source setting (2 channel)
13160  */
13161 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
13162 #define alc268_modes            alc260_modes
13163
13164 static const hda_nid_t alc268_dac_nids[2] = {
13165         /* front, hp */
13166         0x02, 0x03
13167 };
13168
13169 static const hda_nid_t alc268_adc_nids[2] = {
13170         /* ADC0-1 */
13171         0x08, 0x07
13172 };
13173
13174 static const hda_nid_t alc268_adc_nids_alt[1] = {
13175         /* ADC0 */
13176         0x08
13177 };
13178
13179 static const hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
13180
13181 static const struct snd_kcontrol_new alc268_base_mixer[] = {
13182         /* output mixer control */
13183         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13184         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13185         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13186         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13187         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13188         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13189         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13190         { }
13191 };
13192
13193 static const struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13194         /* output mixer control */
13195         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13196         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13197         ALC262_HIPPO_MASTER_SWITCH,
13198         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13199         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13200         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13201         { }
13202 };
13203
13204 /* bind Beep switches of both NID 0x0f and 0x10 */
13205 static const struct hda_bind_ctls alc268_bind_beep_sw = {
13206         .ops = &snd_hda_bind_sw,
13207         .values = {
13208                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13209                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13210                 0
13211         },
13212 };
13213
13214 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
13215         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13216         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13217         { }
13218 };
13219
13220 static const struct hda_verb alc268_eapd_verbs[] = {
13221         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13222         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13223         { }
13224 };
13225
13226 /* Toshiba specific */
13227 static const struct hda_verb alc268_toshiba_verbs[] = {
13228         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13229         { } /* end */
13230 };
13231
13232 /* Acer specific */
13233 /* bind volumes of both NID 0x02 and 0x03 */
13234 static const struct hda_bind_ctls alc268_acer_bind_master_vol = {
13235         .ops = &snd_hda_bind_vol,
13236         .values = {
13237                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13238                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13239                 0
13240         },
13241 };
13242
13243 static void alc268_acer_setup(struct hda_codec *codec)
13244 {
13245         struct alc_spec *spec = codec->spec;
13246
13247         spec->autocfg.hp_pins[0] = 0x14;
13248         spec->autocfg.speaker_pins[0] = 0x15;
13249         spec->automute = 1;
13250         spec->automute_mode = ALC_AUTOMUTE_AMP;
13251 }
13252
13253 #define alc268_acer_master_sw_get       alc262_hp_master_sw_get
13254 #define alc268_acer_master_sw_put       alc262_hp_master_sw_put
13255
13256 static const struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13257         /* output mixer control */
13258         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13259         {
13260                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13261                 .name = "Master Playback Switch",
13262                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x15,
13263                 .info = snd_ctl_boolean_mono_info,
13264                 .get = alc268_acer_master_sw_get,
13265                 .put = alc268_acer_master_sw_put,
13266         },
13267         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13268         { }
13269 };
13270
13271 static const struct snd_kcontrol_new alc268_acer_mixer[] = {
13272         /* output mixer control */
13273         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13274         {
13275                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13276                 .name = "Master Playback Switch",
13277                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
13278                 .info = snd_ctl_boolean_mono_info,
13279                 .get = alc268_acer_master_sw_get,
13280                 .put = alc268_acer_master_sw_put,
13281         },
13282         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13283         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13284         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13285         { }
13286 };
13287
13288 static const struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13289         /* output mixer control */
13290         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13291         {
13292                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13293                 .name = "Master Playback Switch",
13294                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
13295                 .info = snd_ctl_boolean_mono_info,
13296                 .get = alc268_acer_master_sw_get,
13297                 .put = alc268_acer_master_sw_put,
13298         },
13299         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13300         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13301         { }
13302 };
13303
13304 static const struct hda_verb alc268_acer_aspire_one_verbs[] = {
13305         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13306         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13307         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13308         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13309         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13310         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13311         { }
13312 };
13313
13314 static const struct hda_verb alc268_acer_verbs[] = {
13315         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13316         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13317         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13318         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13319         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13320         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13321         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13322         { }
13323 };
13324
13325 /* unsolicited event for HP jack sensing */
13326 #define alc268_toshiba_setup            alc262_hippo_setup
13327
13328 static void alc268_acer_lc_setup(struct hda_codec *codec)
13329 {
13330         struct alc_spec *spec = codec->spec;
13331         spec->autocfg.hp_pins[0] = 0x15;
13332         spec->autocfg.speaker_pins[0] = 0x14;
13333         spec->automute = 1;
13334         spec->automute_mode = ALC_AUTOMUTE_AMP;
13335         spec->ext_mic.pin = 0x18;
13336         spec->ext_mic.mux_idx = 0;
13337         spec->int_mic.pin = 0x12;
13338         spec->int_mic.mux_idx = 6;
13339         spec->auto_mic = 1;
13340 }
13341
13342 static const struct snd_kcontrol_new alc268_dell_mixer[] = {
13343         /* output mixer control */
13344         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13345         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13346         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13347         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13348         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13349         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13350         { }
13351 };
13352
13353 static const struct hda_verb alc268_dell_verbs[] = {
13354         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13355         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13356         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13357         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13358         { }
13359 };
13360
13361 /* mute/unmute internal speaker according to the hp jack and mute state */
13362 static void alc268_dell_setup(struct hda_codec *codec)
13363 {
13364         struct alc_spec *spec = codec->spec;
13365
13366         spec->autocfg.hp_pins[0] = 0x15;
13367         spec->autocfg.speaker_pins[0] = 0x14;
13368         spec->ext_mic.pin = 0x18;
13369         spec->ext_mic.mux_idx = 0;
13370         spec->int_mic.pin = 0x19;
13371         spec->int_mic.mux_idx = 1;
13372         spec->auto_mic = 1;
13373         spec->automute = 1;
13374         spec->automute_mode = ALC_AUTOMUTE_PIN;
13375 }
13376
13377 static const struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13378         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13379         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13380         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13381         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13382         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13383         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13384         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13385         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13386         { }
13387 };
13388
13389 static const struct hda_verb alc267_quanta_il1_verbs[] = {
13390         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13391         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13392         { }
13393 };
13394
13395 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13396 {
13397         struct alc_spec *spec = codec->spec;
13398         spec->autocfg.hp_pins[0] = 0x15;
13399         spec->autocfg.speaker_pins[0] = 0x14;
13400         spec->ext_mic.pin = 0x18;
13401         spec->ext_mic.mux_idx = 0;
13402         spec->int_mic.pin = 0x19;
13403         spec->int_mic.mux_idx = 1;
13404         spec->auto_mic = 1;
13405         spec->automute = 1;
13406         spec->automute_mode = ALC_AUTOMUTE_PIN;
13407 }
13408
13409 /*
13410  * generic initialization of ADC, input mixers and output mixers
13411  */
13412 static const struct hda_verb alc268_base_init_verbs[] = {
13413         /* Unmute DAC0-1 and set vol = 0 */
13414         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13415         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13416
13417         /*
13418          * Set up output mixers (0x0c - 0x0e)
13419          */
13420         /* set vol=0 to output mixers */
13421         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13422         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13423
13424         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13425         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13426
13427         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13428         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13429         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13430         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13431         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13432         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13433         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13434         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13435
13436         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13437         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13438         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13439         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13440         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13441
13442         /* set PCBEEP vol = 0, mute connections */
13443         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13444         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13445         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13446
13447         /* Unmute Selector 23h,24h and set the default input to mic-in */
13448
13449         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13450         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13451         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13452         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13453
13454         { }
13455 };
13456
13457 /*
13458  * generic initialization of ADC, input mixers and output mixers
13459  */
13460 static const struct hda_verb alc268_volume_init_verbs[] = {
13461         /* set output DAC */
13462         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13463         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13464
13465         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13466         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13467         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13468         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13469         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13470
13471         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13472         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13473         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13474
13475         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13476         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13477
13478         /* set PCBEEP vol = 0, mute connections */
13479         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13480         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13481         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13482
13483         { }
13484 };
13485
13486 static const struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13487         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13488         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13489         { } /* end */
13490 };
13491
13492 static const struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13493         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13494         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13495         _DEFINE_CAPSRC(1),
13496         { } /* end */
13497 };
13498
13499 static const struct snd_kcontrol_new alc268_capture_mixer[] = {
13500         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13501         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13502         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13503         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13504         _DEFINE_CAPSRC(2),
13505         { } /* end */
13506 };
13507
13508 static const struct hda_input_mux alc268_capture_source = {
13509         .num_items = 4,
13510         .items = {
13511                 { "Mic", 0x0 },
13512                 { "Front Mic", 0x1 },
13513                 { "Line", 0x2 },
13514                 { "CD", 0x3 },
13515         },
13516 };
13517
13518 static const struct hda_input_mux alc268_acer_capture_source = {
13519         .num_items = 3,
13520         .items = {
13521                 { "Mic", 0x0 },
13522                 { "Internal Mic", 0x1 },
13523                 { "Line", 0x2 },
13524         },
13525 };
13526
13527 static const struct hda_input_mux alc268_acer_dmic_capture_source = {
13528         .num_items = 3,
13529         .items = {
13530                 { "Mic", 0x0 },
13531                 { "Internal Mic", 0x6 },
13532                 { "Line", 0x2 },
13533         },
13534 };
13535
13536 #ifdef CONFIG_SND_DEBUG
13537 static const struct snd_kcontrol_new alc268_test_mixer[] = {
13538         /* Volume widgets */
13539         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13540         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13541         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13542         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13543         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13544         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13545         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13546         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13547         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13548         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13549         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13550         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13551         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13552         /* The below appears problematic on some hardwares */
13553         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13554         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13555         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13556         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13557         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13558
13559         /* Modes for retasking pin widgets */
13560         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13561         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13562         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13563         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13564
13565         /* Controls for GPIO pins, assuming they are configured as outputs */
13566         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13567         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13568         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13569         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13570
13571         /* Switches to allow the digital SPDIF output pin to be enabled.
13572          * The ALC268 does not have an SPDIF input.
13573          */
13574         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13575
13576         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13577          * this output to turn on an external amplifier.
13578          */
13579         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13580         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13581
13582         { } /* end */
13583 };
13584 #endif
13585
13586 /* create input playback/capture controls for the given pin */
13587 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13588                                     const char *ctlname, int idx)
13589 {
13590         hda_nid_t dac;
13591         int err;
13592
13593         switch (nid) {
13594         case 0x14:
13595         case 0x16:
13596                 dac = 0x02;
13597                 break;
13598         case 0x15:
13599         case 0x1a: /* ALC259/269 only */
13600         case 0x1b: /* ALC259/269 only */
13601         case 0x21: /* ALC269vb has this pin, too */
13602                 dac = 0x03;
13603                 break;
13604         default:
13605                 snd_printd(KERN_WARNING "hda_codec: "
13606                            "ignoring pin 0x%x as unknown\n", nid);
13607                 return 0;
13608         }
13609         if (spec->multiout.dac_nids[0] != dac &&
13610             spec->multiout.dac_nids[1] != dac) {
13611                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13612                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13613                                                       HDA_OUTPUT));
13614                 if (err < 0)
13615                         return err;
13616                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
13617         }
13618
13619         if (nid != 0x16)
13620                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13621                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13622         else /* mono */
13623                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13624                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13625         if (err < 0)
13626                 return err;
13627         return 0;
13628 }
13629
13630 /* add playback controls from the parsed DAC table */
13631 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13632                                              const struct auto_pin_cfg *cfg)
13633 {
13634         hda_nid_t nid;
13635         int err;
13636
13637         spec->multiout.dac_nids = spec->private_dac_nids;
13638
13639         nid = cfg->line_out_pins[0];
13640         if (nid) {
13641                 const char *name;
13642                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13643                         name = "Speaker";
13644                 else
13645                         name = "Front";
13646                 err = alc268_new_analog_output(spec, nid, name, 0);
13647                 if (err < 0)
13648                         return err;
13649         }
13650
13651         nid = cfg->speaker_pins[0];
13652         if (nid == 0x1d) {
13653                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13654                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13655                 if (err < 0)
13656                         return err;
13657         } else if (nid) {
13658                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13659                 if (err < 0)
13660                         return err;
13661         }
13662         nid = cfg->hp_pins[0];
13663         if (nid) {
13664                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13665                 if (err < 0)
13666                         return err;
13667         }
13668
13669         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13670         if (nid == 0x16) {
13671                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13672                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13673                 if (err < 0)
13674                         return err;
13675         }
13676         return 0;
13677 }
13678
13679 /* create playback/capture controls for input pins */
13680 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13681                                                 const struct auto_pin_cfg *cfg)
13682 {
13683         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13684 }
13685
13686 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13687                                               hda_nid_t nid, int pin_type)
13688 {
13689         int idx;
13690
13691         alc_set_pin_output(codec, nid, pin_type);
13692         if (nid == 0x14 || nid == 0x16)
13693                 idx = 0;
13694         else
13695                 idx = 1;
13696         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13697 }
13698
13699 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13700 {
13701         struct alc_spec *spec = codec->spec;
13702         int i;
13703
13704         for (i = 0; i < spec->autocfg.line_outs; i++) {
13705                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13706                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13707                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13708         }
13709 }
13710
13711 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13712 {
13713         struct alc_spec *spec = codec->spec;
13714         hda_nid_t pin;
13715         int i;
13716
13717         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13718                 pin = spec->autocfg.hp_pins[i];
13719                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13720         }
13721         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13722                 pin = spec->autocfg.speaker_pins[i];
13723                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13724         }
13725         if (spec->autocfg.mono_out_pin)
13726                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13727                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13728 }
13729
13730 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13731 {
13732         struct alc_spec *spec = codec->spec;
13733         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13734         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13735         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13736         unsigned int    dac_vol1, dac_vol2;
13737
13738         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13739                 snd_hda_codec_write(codec, speaker_nid, 0,
13740                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13741                 /* mute mixer inputs from 0x1d */
13742                 snd_hda_codec_write(codec, 0x0f, 0,
13743                                     AC_VERB_SET_AMP_GAIN_MUTE,
13744                                     AMP_IN_UNMUTE(1));
13745                 snd_hda_codec_write(codec, 0x10, 0,
13746                                     AC_VERB_SET_AMP_GAIN_MUTE,
13747                                     AMP_IN_UNMUTE(1));
13748         } else {
13749                 /* unmute mixer inputs from 0x1d */
13750                 snd_hda_codec_write(codec, 0x0f, 0,
13751                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13752                 snd_hda_codec_write(codec, 0x10, 0,
13753                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13754         }
13755
13756         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13757         if (line_nid == 0x14)
13758                 dac_vol2 = AMP_OUT_ZERO;
13759         else if (line_nid == 0x15)
13760                 dac_vol1 = AMP_OUT_ZERO;
13761         if (hp_nid == 0x14)
13762                 dac_vol2 = AMP_OUT_ZERO;
13763         else if (hp_nid == 0x15)
13764                 dac_vol1 = AMP_OUT_ZERO;
13765         if (line_nid != 0x16 || hp_nid != 0x16 ||
13766             spec->autocfg.line_out_pins[1] != 0x16 ||
13767             spec->autocfg.line_out_pins[2] != 0x16)
13768                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13769
13770         snd_hda_codec_write(codec, 0x02, 0,
13771                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13772         snd_hda_codec_write(codec, 0x03, 0,
13773                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13774 }
13775
13776 /* pcm configuration: identical with ALC880 */
13777 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13778 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13779 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13780 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13781
13782 /*
13783  * BIOS auto configuration
13784  */
13785 static int alc268_parse_auto_config(struct hda_codec *codec)
13786 {
13787         struct alc_spec *spec = codec->spec;
13788         int err;
13789         static const hda_nid_t alc268_ignore[] = { 0 };
13790
13791         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13792                                            alc268_ignore);
13793         if (err < 0)
13794                 return err;
13795         if (!spec->autocfg.line_outs) {
13796                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13797                         spec->multiout.max_channels = 2;
13798                         spec->no_analog = 1;
13799                         goto dig_only;
13800                 }
13801                 return 0; /* can't find valid BIOS pin config */
13802         }
13803         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13804         if (err < 0)
13805                 return err;
13806         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13807         if (err < 0)
13808                 return err;
13809
13810         spec->multiout.max_channels = 2;
13811
13812  dig_only:
13813         /* digital only support output */
13814         alc_auto_parse_digital(codec);
13815         if (spec->kctls.list)
13816                 add_mixer(spec, spec->kctls.list);
13817
13818         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13819                 add_mixer(spec, alc268_beep_mixer);
13820
13821         add_verb(spec, alc268_volume_init_verbs);
13822         spec->num_mux_defs = 2;
13823         spec->input_mux = &spec->private_imux[0];
13824
13825         err = alc_auto_add_mic_boost(codec);
13826         if (err < 0)
13827                 return err;
13828
13829         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13830
13831         return 1;
13832 }
13833
13834 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13835 #define alc268_auto_init_input_src      alc882_auto_init_input_src
13836
13837 /* init callback for auto-configuration model -- overriding the default init */
13838 static void alc268_auto_init(struct hda_codec *codec)
13839 {
13840         struct alc_spec *spec = codec->spec;
13841         alc268_auto_init_multi_out(codec);
13842         alc268_auto_init_hp_out(codec);
13843         alc268_auto_init_mono_speaker_out(codec);
13844         alc268_auto_init_analog_input(codec);
13845         alc268_auto_init_input_src(codec);
13846         alc_auto_init_digital(codec);
13847         if (spec->unsol_event)
13848                 alc_inithook(codec);
13849 }
13850
13851 /*
13852  * configuration and preset
13853  */
13854 static const char * const alc268_models[ALC268_MODEL_LAST] = {
13855         [ALC267_QUANTA_IL1]     = "quanta-il1",
13856         [ALC268_3ST]            = "3stack",
13857         [ALC268_TOSHIBA]        = "toshiba",
13858         [ALC268_ACER]           = "acer",
13859         [ALC268_ACER_DMIC]      = "acer-dmic",
13860         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13861         [ALC268_DELL]           = "dell",
13862         [ALC268_ZEPTO]          = "zepto",
13863 #ifdef CONFIG_SND_DEBUG
13864         [ALC268_TEST]           = "test",
13865 #endif
13866         [ALC268_AUTO]           = "auto",
13867 };
13868
13869 static const struct snd_pci_quirk alc268_cfg_tbl[] = {
13870         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13871         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13872         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13873         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13874         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13875         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13876                                                 ALC268_ACER_ASPIRE_ONE),
13877         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13878         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron 910", ALC268_AUTO),
13879         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13880                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13881         /* almost compatible with toshiba but with optional digital outs;
13882          * auto-probing seems working fine
13883          */
13884         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13885                            ALC268_AUTO),
13886         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13887         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13888         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13889         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13890         {}
13891 };
13892
13893 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13894 static const struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13895         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13896         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13897         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13898                            ALC268_TOSHIBA),
13899         {}
13900 };
13901
13902 static const struct alc_config_preset alc268_presets[] = {
13903         [ALC267_QUANTA_IL1] = {
13904                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13905                             alc268_capture_nosrc_mixer },
13906                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13907                                 alc267_quanta_il1_verbs },
13908                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13909                 .dac_nids = alc268_dac_nids,
13910                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13911                 .adc_nids = alc268_adc_nids_alt,
13912                 .hp_nid = 0x03,
13913                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13914                 .channel_mode = alc268_modes,
13915                 .unsol_event = alc_sku_unsol_event,
13916                 .setup = alc267_quanta_il1_setup,
13917                 .init_hook = alc_inithook,
13918         },
13919         [ALC268_3ST] = {
13920                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13921                             alc268_beep_mixer },
13922                 .init_verbs = { alc268_base_init_verbs },
13923                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13924                 .dac_nids = alc268_dac_nids,
13925                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13926                 .adc_nids = alc268_adc_nids_alt,
13927                 .capsrc_nids = alc268_capsrc_nids,
13928                 .hp_nid = 0x03,
13929                 .dig_out_nid = ALC268_DIGOUT_NID,
13930                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13931                 .channel_mode = alc268_modes,
13932                 .input_mux = &alc268_capture_source,
13933         },
13934         [ALC268_TOSHIBA] = {
13935                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13936                             alc268_beep_mixer },
13937                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13938                                 alc268_toshiba_verbs },
13939                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13940                 .dac_nids = alc268_dac_nids,
13941                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13942                 .adc_nids = alc268_adc_nids_alt,
13943                 .capsrc_nids = alc268_capsrc_nids,
13944                 .hp_nid = 0x03,
13945                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13946                 .channel_mode = alc268_modes,
13947                 .input_mux = &alc268_capture_source,
13948                 .unsol_event = alc_sku_unsol_event,
13949                 .setup = alc268_toshiba_setup,
13950                 .init_hook = alc_inithook,
13951         },
13952         [ALC268_ACER] = {
13953                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13954                             alc268_beep_mixer },
13955                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13956                                 alc268_acer_verbs },
13957                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13958                 .dac_nids = alc268_dac_nids,
13959                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13960                 .adc_nids = alc268_adc_nids_alt,
13961                 .capsrc_nids = alc268_capsrc_nids,
13962                 .hp_nid = 0x02,
13963                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13964                 .channel_mode = alc268_modes,
13965                 .input_mux = &alc268_acer_capture_source,
13966                 .unsol_event = alc_sku_unsol_event,
13967                 .setup = alc268_acer_setup,
13968                 .init_hook = alc_inithook,
13969         },
13970         [ALC268_ACER_DMIC] = {
13971                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13972                             alc268_beep_mixer },
13973                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13974                                 alc268_acer_verbs },
13975                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13976                 .dac_nids = alc268_dac_nids,
13977                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13978                 .adc_nids = alc268_adc_nids_alt,
13979                 .capsrc_nids = alc268_capsrc_nids,
13980                 .hp_nid = 0x02,
13981                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13982                 .channel_mode = alc268_modes,
13983                 .input_mux = &alc268_acer_dmic_capture_source,
13984                 .unsol_event = alc_sku_unsol_event,
13985                 .setup = alc268_acer_setup,
13986                 .init_hook = alc_inithook,
13987         },
13988         [ALC268_ACER_ASPIRE_ONE] = {
13989                 .mixers = { alc268_acer_aspire_one_mixer,
13990                             alc268_beep_mixer,
13991                             alc268_capture_nosrc_mixer },
13992                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13993                                 alc268_acer_aspire_one_verbs },
13994                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13995                 .dac_nids = alc268_dac_nids,
13996                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13997                 .adc_nids = alc268_adc_nids_alt,
13998                 .capsrc_nids = alc268_capsrc_nids,
13999                 .hp_nid = 0x03,
14000                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14001                 .channel_mode = alc268_modes,
14002                 .unsol_event = alc_sku_unsol_event,
14003                 .setup = alc268_acer_lc_setup,
14004                 .init_hook = alc_inithook,
14005         },
14006         [ALC268_DELL] = {
14007                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
14008                             alc268_capture_nosrc_mixer },
14009                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14010                                 alc268_dell_verbs },
14011                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14012                 .dac_nids = alc268_dac_nids,
14013                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14014                 .adc_nids = alc268_adc_nids_alt,
14015                 .capsrc_nids = alc268_capsrc_nids,
14016                 .hp_nid = 0x02,
14017                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14018                 .channel_mode = alc268_modes,
14019                 .unsol_event = alc_sku_unsol_event,
14020                 .setup = alc268_dell_setup,
14021                 .init_hook = alc_inithook,
14022         },
14023         [ALC268_ZEPTO] = {
14024                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
14025                             alc268_beep_mixer },
14026                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14027                                 alc268_toshiba_verbs },
14028                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14029                 .dac_nids = alc268_dac_nids,
14030                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14031                 .adc_nids = alc268_adc_nids_alt,
14032                 .capsrc_nids = alc268_capsrc_nids,
14033                 .hp_nid = 0x03,
14034                 .dig_out_nid = ALC268_DIGOUT_NID,
14035                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14036                 .channel_mode = alc268_modes,
14037                 .input_mux = &alc268_capture_source,
14038                 .unsol_event = alc_sku_unsol_event,
14039                 .setup = alc268_toshiba_setup,
14040                 .init_hook = alc_inithook,
14041         },
14042 #ifdef CONFIG_SND_DEBUG
14043         [ALC268_TEST] = {
14044                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
14045                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14046                                 alc268_volume_init_verbs },
14047                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14048                 .dac_nids = alc268_dac_nids,
14049                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14050                 .adc_nids = alc268_adc_nids_alt,
14051                 .capsrc_nids = alc268_capsrc_nids,
14052                 .hp_nid = 0x03,
14053                 .dig_out_nid = ALC268_DIGOUT_NID,
14054                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14055                 .channel_mode = alc268_modes,
14056                 .input_mux = &alc268_capture_source,
14057         },
14058 #endif
14059 };
14060
14061 static int patch_alc268(struct hda_codec *codec)
14062 {
14063         struct alc_spec *spec;
14064         int board_config;
14065         int i, has_beep, err;
14066
14067         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14068         if (spec == NULL)
14069                 return -ENOMEM;
14070
14071         codec->spec = spec;
14072
14073         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
14074                                                   alc268_models,
14075                                                   alc268_cfg_tbl);
14076
14077         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
14078                 board_config = snd_hda_check_board_codec_sid_config(codec,
14079                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
14080
14081         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
14082                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14083                        codec->chip_name);
14084                 board_config = ALC268_AUTO;
14085         }
14086
14087         if (board_config == ALC268_AUTO) {
14088                 /* automatic parse from the BIOS config */
14089                 err = alc268_parse_auto_config(codec);
14090                 if (err < 0) {
14091                         alc_free(codec);
14092                         return err;
14093                 } else if (!err) {
14094                         printk(KERN_INFO
14095                                "hda_codec: Cannot set up configuration "
14096                                "from BIOS.  Using base mode...\n");
14097                         board_config = ALC268_3ST;
14098                 }
14099         }
14100
14101         if (board_config != ALC268_AUTO)
14102                 setup_preset(codec, &alc268_presets[board_config]);
14103
14104         spec->stream_analog_playback = &alc268_pcm_analog_playback;
14105         spec->stream_analog_capture = &alc268_pcm_analog_capture;
14106         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
14107
14108         spec->stream_digital_playback = &alc268_pcm_digital_playback;
14109
14110         has_beep = 0;
14111         for (i = 0; i < spec->num_mixers; i++) {
14112                 if (spec->mixers[i] == alc268_beep_mixer) {
14113                         has_beep = 1;
14114                         break;
14115                 }
14116         }
14117
14118         if (has_beep) {
14119                 err = snd_hda_attach_beep_device(codec, 0x1);
14120                 if (err < 0) {
14121                         alc_free(codec);
14122                         return err;
14123                 }
14124                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
14125                         /* override the amp caps for beep generator */
14126                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
14127                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
14128                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14129                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14130                                           (0 << AC_AMPCAP_MUTE_SHIFT));
14131         }
14132
14133         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14134                 /* check whether NID 0x07 is valid */
14135                 unsigned int wcap = get_wcaps(codec, 0x07);
14136
14137                 spec->capsrc_nids = alc268_capsrc_nids;
14138                 /* get type */
14139                 wcap = get_wcaps_type(wcap);
14140                 if (spec->auto_mic ||
14141                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14142                         spec->adc_nids = alc268_adc_nids_alt;
14143                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14144                         if (spec->auto_mic)
14145                                 fixup_automic_adc(codec);
14146                         if (spec->auto_mic || spec->input_mux->num_items == 1)
14147                                 add_mixer(spec, alc268_capture_nosrc_mixer);
14148                         else
14149                                 add_mixer(spec, alc268_capture_alt_mixer);
14150                 } else {
14151                         spec->adc_nids = alc268_adc_nids;
14152                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14153                         add_mixer(spec, alc268_capture_mixer);
14154                 }
14155         }
14156
14157         spec->vmaster_nid = 0x02;
14158
14159         codec->patch_ops = alc_patch_ops;
14160         if (board_config == ALC268_AUTO)
14161                 spec->init_hook = alc268_auto_init;
14162         spec->shutup = alc_eapd_shutup;
14163
14164         alc_init_jacks(codec);
14165
14166         return 0;
14167 }
14168
14169 /*
14170  *  ALC269 channel source setting (2 channel)
14171  */
14172 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
14173
14174 #define alc269_dac_nids         alc260_dac_nids
14175
14176 static const hda_nid_t alc269_adc_nids[1] = {
14177         /* ADC1 */
14178         0x08,
14179 };
14180
14181 static const hda_nid_t alc269_capsrc_nids[1] = {
14182         0x23,
14183 };
14184
14185 static const hda_nid_t alc269vb_adc_nids[1] = {
14186         /* ADC1 */
14187         0x09,
14188 };
14189
14190 static const hda_nid_t alc269vb_capsrc_nids[1] = {
14191         0x22,
14192 };
14193
14194 static const hda_nid_t alc269_adc_candidates[] = {
14195         0x08, 0x09, 0x07, 0x11,
14196 };
14197
14198 #define alc269_modes            alc260_modes
14199 #define alc269_capture_source   alc880_lg_lw_capture_source
14200
14201 static const struct snd_kcontrol_new alc269_base_mixer[] = {
14202         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14203         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14204         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14205         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14206         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14207         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14208         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14209         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14210         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14211         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
14212         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14213         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14214         { } /* end */
14215 };
14216
14217 static const struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14218         /* output mixer control */
14219         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14220         {
14221                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14222                 .name = "Master Playback Switch",
14223                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14224                 .info = snd_hda_mixer_amp_switch_info,
14225                 .get = snd_hda_mixer_amp_switch_get,
14226                 .put = alc268_acer_master_sw_put,
14227                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14228         },
14229         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14230         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14231         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14232         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14233         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14234         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14235         { }
14236 };
14237
14238 static const struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14239         /* output mixer control */
14240         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14241         {
14242                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14243                 .name = "Master Playback Switch",
14244                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14245                 .info = snd_hda_mixer_amp_switch_info,
14246                 .get = snd_hda_mixer_amp_switch_get,
14247                 .put = alc268_acer_master_sw_put,
14248                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14249         },
14250         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14251         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14252         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14253         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14254         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14255         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14256         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14257         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14258         HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
14259         { }
14260 };
14261
14262 static const struct snd_kcontrol_new alc269_laptop_mixer[] = {
14263         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14264         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14265         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14266         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14267         { } /* end */
14268 };
14269
14270 static const struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14271         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14272         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14273         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14274         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14275         { } /* end */
14276 };
14277
14278 static const struct snd_kcontrol_new alc269_asus_mixer[] = {
14279         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14280         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14281         { } /* end */
14282 };
14283
14284 /* capture mixer elements */
14285 static const struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14286         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14287         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14288         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14289         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14290         { } /* end */
14291 };
14292
14293 static const struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14294         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14295         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14296         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14297         { } /* end */
14298 };
14299
14300 static const struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14301         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14302         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14303         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14304         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14305         { } /* end */
14306 };
14307
14308 static const struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14309         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14310         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14311         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14312         { } /* end */
14313 };
14314
14315 /* FSC amilo */
14316 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14317
14318 static const struct hda_verb alc269_quanta_fl1_verbs[] = {
14319         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14320         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14321         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14322         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14323         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14324         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14325         { }
14326 };
14327
14328 static const struct hda_verb alc269_lifebook_verbs[] = {
14329         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14330         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14331         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14332         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14333         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14334         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14335         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14336         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14337         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14338         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14339         { }
14340 };
14341
14342 /* toggle speaker-output according to the hp-jack state */
14343 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14344 {
14345         alc_hp_automute(codec);
14346
14347         snd_hda_codec_write(codec, 0x20, 0,
14348                         AC_VERB_SET_COEF_INDEX, 0x0c);
14349         snd_hda_codec_write(codec, 0x20, 0,
14350                         AC_VERB_SET_PROC_COEF, 0x680);
14351
14352         snd_hda_codec_write(codec, 0x20, 0,
14353                         AC_VERB_SET_COEF_INDEX, 0x0c);
14354         snd_hda_codec_write(codec, 0x20, 0,
14355                         AC_VERB_SET_PROC_COEF, 0x480);
14356 }
14357
14358 #define alc269_lifebook_speaker_automute \
14359         alc269_quanta_fl1_speaker_automute
14360
14361 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14362 {
14363         unsigned int present_laptop;
14364         unsigned int present_dock;
14365
14366         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14367         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14368
14369         /* Laptop mic port overrides dock mic port, design decision */
14370         if (present_dock)
14371                 snd_hda_codec_write(codec, 0x23, 0,
14372                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14373         if (present_laptop)
14374                 snd_hda_codec_write(codec, 0x23, 0,
14375                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14376         if (!present_dock && !present_laptop)
14377                 snd_hda_codec_write(codec, 0x23, 0,
14378                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14379 }
14380
14381 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14382                                     unsigned int res)
14383 {
14384         switch (res >> 26) {
14385         case ALC880_HP_EVENT:
14386                 alc269_quanta_fl1_speaker_automute(codec);
14387                 break;
14388         case ALC880_MIC_EVENT:
14389                 alc_mic_automute(codec);
14390                 break;
14391         }
14392 }
14393
14394 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14395                                         unsigned int res)
14396 {
14397         if ((res >> 26) == ALC880_HP_EVENT)
14398                 alc269_lifebook_speaker_automute(codec);
14399         if ((res >> 26) == ALC880_MIC_EVENT)
14400                 alc269_lifebook_mic_autoswitch(codec);
14401 }
14402
14403 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14404 {
14405         struct alc_spec *spec = codec->spec;
14406         spec->autocfg.hp_pins[0] = 0x15;
14407         spec->autocfg.speaker_pins[0] = 0x14;
14408         spec->automute_mixer_nid[0] = 0x0c;
14409         spec->automute = 1;
14410         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14411         spec->ext_mic.pin = 0x18;
14412         spec->ext_mic.mux_idx = 0;
14413         spec->int_mic.pin = 0x19;
14414         spec->int_mic.mux_idx = 1;
14415         spec->auto_mic = 1;
14416 }
14417
14418 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14419 {
14420         alc269_quanta_fl1_speaker_automute(codec);
14421         alc_mic_automute(codec);
14422 }
14423
14424 static void alc269_lifebook_setup(struct hda_codec *codec)
14425 {
14426         struct alc_spec *spec = codec->spec;
14427         spec->autocfg.hp_pins[0] = 0x15;
14428         spec->autocfg.hp_pins[1] = 0x1a;
14429         spec->autocfg.speaker_pins[0] = 0x14;
14430         spec->automute_mixer_nid[0] = 0x0c;
14431         spec->automute = 1;
14432         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14433 }
14434
14435 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14436 {
14437         alc269_lifebook_speaker_automute(codec);
14438         alc269_lifebook_mic_autoswitch(codec);
14439 }
14440
14441 static const struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14442         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14443         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14444         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14445         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14446         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14447         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14448         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14449         {}
14450 };
14451
14452 static const struct hda_verb alc269_laptop_amic_init_verbs[] = {
14453         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14454         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14455         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14456         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14457         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14458         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14459         {}
14460 };
14461
14462 static const struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14463         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14464         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14465         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14466         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14467         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14468         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14469         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14470         {}
14471 };
14472
14473 static const struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14474         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14475         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14476         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14477         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14478         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14479         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14480         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14481         {}
14482 };
14483
14484 static const struct hda_verb alc271_acer_dmic_verbs[] = {
14485         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14486         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14487         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14488         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14489         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14490         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14491         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14492         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14493         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14494         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14495         { }
14496 };
14497
14498 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14499 {
14500         struct alc_spec *spec = codec->spec;
14501         spec->autocfg.hp_pins[0] = 0x15;
14502         spec->autocfg.speaker_pins[0] = 0x14;
14503         spec->automute_mixer_nid[0] = 0x0c;
14504         spec->automute = 1;
14505         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14506         spec->ext_mic.pin = 0x18;
14507         spec->ext_mic.mux_idx = 0;
14508         spec->int_mic.pin = 0x19;
14509         spec->int_mic.mux_idx = 1;
14510         spec->auto_mic = 1;
14511 }
14512
14513 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14514 {
14515         struct alc_spec *spec = codec->spec;
14516         spec->autocfg.hp_pins[0] = 0x15;
14517         spec->autocfg.speaker_pins[0] = 0x14;
14518         spec->automute_mixer_nid[0] = 0x0c;
14519         spec->automute = 1;
14520         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14521         spec->ext_mic.pin = 0x18;
14522         spec->ext_mic.mux_idx = 0;
14523         spec->int_mic.pin = 0x12;
14524         spec->int_mic.mux_idx = 5;
14525         spec->auto_mic = 1;
14526 }
14527
14528 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14529 {
14530         struct alc_spec *spec = codec->spec;
14531         spec->autocfg.hp_pins[0] = 0x21;
14532         spec->autocfg.speaker_pins[0] = 0x14;
14533         spec->automute_mixer_nid[0] = 0x0c;
14534         spec->automute = 1;
14535         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14536         spec->ext_mic.pin = 0x18;
14537         spec->ext_mic.mux_idx = 0;
14538         spec->int_mic.pin = 0x19;
14539         spec->int_mic.mux_idx = 1;
14540         spec->auto_mic = 1;
14541 }
14542
14543 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14544 {
14545         struct alc_spec *spec = codec->spec;
14546         spec->autocfg.hp_pins[0] = 0x21;
14547         spec->autocfg.speaker_pins[0] = 0x14;
14548         spec->automute_mixer_nid[0] = 0x0c;
14549         spec->automute = 1;
14550         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14551         spec->ext_mic.pin = 0x18;
14552         spec->ext_mic.mux_idx = 0;
14553         spec->int_mic.pin = 0x12;
14554         spec->int_mic.mux_idx = 6;
14555         spec->auto_mic = 1;
14556 }
14557
14558 /*
14559  * generic initialization of ADC, input mixers and output mixers
14560  */
14561 static const struct hda_verb alc269_init_verbs[] = {
14562         /*
14563          * Unmute ADC0 and set the default input to mic-in
14564          */
14565         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14566
14567         /*
14568          * Set up output mixers (0x02 - 0x03)
14569          */
14570         /* set vol=0 to output mixers */
14571         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14572         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14573
14574         /* set up input amps for analog loopback */
14575         /* Amp Indices: DAC = 0, mixer = 1 */
14576         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14577         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14578         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14579         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14580         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14581         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14582
14583         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14584         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14585         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14586         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14587         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14588         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14589         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14590
14591         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14592         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14593
14594         /* FIXME: use Mux-type input source selection */
14595         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14596         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14597         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14598
14599         /* set EAPD */
14600         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14601         { }
14602 };
14603
14604 static const struct hda_verb alc269vb_init_verbs[] = {
14605         /*
14606          * Unmute ADC0 and set the default input to mic-in
14607          */
14608         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14609
14610         /*
14611          * Set up output mixers (0x02 - 0x03)
14612          */
14613         /* set vol=0 to output mixers */
14614         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14615         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14616
14617         /* set up input amps for analog loopback */
14618         /* Amp Indices: DAC = 0, mixer = 1 */
14619         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14620         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14621         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14622         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14623         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14624         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14625
14626         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14627         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14628         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14629         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14630         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14631         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14632         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14633
14634         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14635         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14636
14637         /* FIXME: use Mux-type input source selection */
14638         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14639         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14640         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14641
14642         /* set EAPD */
14643         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14644         { }
14645 };
14646
14647 #define alc269_auto_create_multi_out_ctls \
14648         alc268_auto_create_multi_out_ctls
14649 #define alc269_auto_create_input_ctls \
14650         alc268_auto_create_input_ctls
14651
14652 #ifdef CONFIG_SND_HDA_POWER_SAVE
14653 #define alc269_loopbacks        alc880_loopbacks
14654 #endif
14655
14656 /* pcm configuration: identical with ALC880 */
14657 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14658 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14659 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14660 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14661
14662 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14663         .substreams = 1,
14664         .channels_min = 2,
14665         .channels_max = 8,
14666         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14667         /* NID is set in alc_build_pcms */
14668         .ops = {
14669                 .open = alc880_playback_pcm_open,
14670                 .prepare = alc880_playback_pcm_prepare,
14671                 .cleanup = alc880_playback_pcm_cleanup
14672         },
14673 };
14674
14675 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14676         .substreams = 1,
14677         .channels_min = 2,
14678         .channels_max = 2,
14679         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14680         /* NID is set in alc_build_pcms */
14681 };
14682
14683 #ifdef CONFIG_SND_HDA_POWER_SAVE
14684 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14685 {
14686         switch (codec->subsystem_id) {
14687         case 0x103c1586:
14688                 return 1;
14689         }
14690         return 0;
14691 }
14692
14693 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14694 {
14695         /* update mute-LED according to the speaker mute state */
14696         if (nid == 0x01 || nid == 0x14) {
14697                 int pinval;
14698                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14699                     HDA_AMP_MUTE)
14700                         pinval = 0x24;
14701                 else
14702                         pinval = 0x20;
14703                 /* mic2 vref pin is used for mute LED control */
14704                 snd_hda_codec_update_cache(codec, 0x19, 0,
14705                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14706                                            pinval);
14707         }
14708         return alc_check_power_status(codec, nid);
14709 }
14710 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14711
14712 static int alc275_setup_dual_adc(struct hda_codec *codec)
14713 {
14714         struct alc_spec *spec = codec->spec;
14715
14716         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14717                 return 0;
14718         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14719             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14720                 if (spec->ext_mic.pin <= 0x12) {
14721                         spec->private_adc_nids[0] = 0x08;
14722                         spec->private_adc_nids[1] = 0x11;
14723                         spec->private_capsrc_nids[0] = 0x23;
14724                         spec->private_capsrc_nids[1] = 0x22;
14725                 } else {
14726                         spec->private_adc_nids[0] = 0x11;
14727                         spec->private_adc_nids[1] = 0x08;
14728                         spec->private_capsrc_nids[0] = 0x22;
14729                         spec->private_capsrc_nids[1] = 0x23;
14730                 }
14731                 spec->adc_nids = spec->private_adc_nids;
14732                 spec->capsrc_nids = spec->private_capsrc_nids;
14733                 spec->num_adc_nids = 2;
14734                 spec->dual_adc_switch = 1;
14735                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14736                             spec->adc_nids[0], spec->adc_nids[1]);
14737                 return 1;
14738         }
14739         return 0;
14740 }
14741
14742 /* different alc269-variants */
14743 enum {
14744         ALC269_TYPE_NORMAL,
14745         ALC269_TYPE_ALC258,
14746         ALC269_TYPE_ALC259,
14747         ALC269_TYPE_ALC269VB,
14748         ALC269_TYPE_ALC270,
14749         ALC269_TYPE_ALC271X,
14750 };
14751
14752 /*
14753  * BIOS auto configuration
14754  */
14755 static int alc269_parse_auto_config(struct hda_codec *codec)
14756 {
14757         struct alc_spec *spec = codec->spec;
14758         int err;
14759         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14760
14761         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14762                                            alc269_ignore);
14763         if (err < 0)
14764                 return err;
14765
14766         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14767         if (err < 0)
14768                 return err;
14769         if (spec->codec_variant == ALC269_TYPE_NORMAL)
14770                 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14771         else
14772                 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14773                                                  0x22, 0);
14774         if (err < 0)
14775                 return err;
14776
14777         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14778
14779         alc_auto_parse_digital(codec);
14780
14781         if (spec->kctls.list)
14782                 add_mixer(spec, spec->kctls.list);
14783
14784         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14785                 add_verb(spec, alc269vb_init_verbs);
14786                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14787         } else {
14788                 add_verb(spec, alc269_init_verbs);
14789                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14790         }
14791
14792         spec->num_mux_defs = 1;
14793         spec->input_mux = &spec->private_imux[0];
14794
14795         if (!alc275_setup_dual_adc(codec))
14796                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14797                                      sizeof(alc269_adc_candidates));
14798
14799         err = alc_auto_add_mic_boost(codec);
14800         if (err < 0)
14801                 return err;
14802
14803         if (!spec->cap_mixer && !spec->no_analog)
14804                 set_capture_mixer(codec);
14805
14806         return 1;
14807 }
14808
14809 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14810 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14811 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14812 #define alc269_auto_init_input_src      alc882_auto_init_input_src
14813
14814
14815 /* init callback for auto-configuration model -- overriding the default init */
14816 static void alc269_auto_init(struct hda_codec *codec)
14817 {
14818         struct alc_spec *spec = codec->spec;
14819         alc269_auto_init_multi_out(codec);
14820         alc269_auto_init_hp_out(codec);
14821         alc269_auto_init_analog_input(codec);
14822         if (!spec->dual_adc_switch)
14823                 alc269_auto_init_input_src(codec);
14824         alc_auto_init_digital(codec);
14825         if (spec->unsol_event)
14826                 alc_inithook(codec);
14827 }
14828
14829 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14830 {
14831         int val = alc_read_coef_idx(codec, 0x04);
14832         if (power_up)
14833                 val |= 1 << 11;
14834         else
14835                 val &= ~(1 << 11);
14836         alc_write_coef_idx(codec, 0x04, val);
14837 }
14838
14839 static void alc269_shutup(struct hda_codec *codec)
14840 {
14841         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14842                 alc269_toggle_power_output(codec, 0);
14843         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14844                 alc269_toggle_power_output(codec, 0);
14845                 msleep(150);
14846         }
14847 }
14848
14849 #ifdef SND_HDA_NEEDS_RESUME
14850 static int alc269_resume(struct hda_codec *codec)
14851 {
14852         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14853                 alc269_toggle_power_output(codec, 0);
14854                 msleep(150);
14855         }
14856
14857         codec->patch_ops.init(codec);
14858
14859         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14860                 alc269_toggle_power_output(codec, 1);
14861                 msleep(200);
14862         }
14863
14864         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14865                 alc269_toggle_power_output(codec, 1);
14866
14867         snd_hda_codec_resume_amp(codec);
14868         snd_hda_codec_resume_cache(codec);
14869         hda_call_check_power_status(codec, 0x01);
14870         return 0;
14871 }
14872 #endif /* SND_HDA_NEEDS_RESUME */
14873
14874 static void alc269_fixup_hweq(struct hda_codec *codec,
14875                                const struct alc_fixup *fix, int action)
14876 {
14877         int coef;
14878
14879         if (action != ALC_FIXUP_ACT_INIT)
14880                 return;
14881         coef = alc_read_coef_idx(codec, 0x1e);
14882         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
14883 }
14884
14885 static void alc271_fixup_dmic(struct hda_codec *codec,
14886                               const struct alc_fixup *fix, int action)
14887 {
14888         static const struct hda_verb verbs[] = {
14889                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14890                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14891                 {}
14892         };
14893         unsigned int cfg;
14894
14895         if (strcmp(codec->chip_name, "ALC271X"))
14896                 return;
14897         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
14898         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
14899                 snd_hda_sequence_write(codec, verbs);
14900 }
14901
14902 enum {
14903         ALC269_FIXUP_SONY_VAIO,
14904         ALC275_FIXUP_SONY_VAIO_GPIO2,
14905         ALC269_FIXUP_DELL_M101Z,
14906         ALC269_FIXUP_SKU_IGNORE,
14907         ALC269_FIXUP_ASUS_G73JW,
14908         ALC269_FIXUP_LENOVO_EAPD,
14909         ALC275_FIXUP_SONY_HWEQ,
14910         ALC271_FIXUP_DMIC,
14911 };
14912
14913 static const struct alc_fixup alc269_fixups[] = {
14914         [ALC269_FIXUP_SONY_VAIO] = {
14915                 .type = ALC_FIXUP_VERBS,
14916                 .v.verbs = (const struct hda_verb[]) {
14917                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14918                         {}
14919                 }
14920         },
14921         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
14922                 .type = ALC_FIXUP_VERBS,
14923                 .v.verbs = (const struct hda_verb[]) {
14924                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14925                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14926                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14927                         { }
14928                 },
14929                 .chained = true,
14930                 .chain_id = ALC269_FIXUP_SONY_VAIO
14931         },
14932         [ALC269_FIXUP_DELL_M101Z] = {
14933                 .type = ALC_FIXUP_VERBS,
14934                 .v.verbs = (const struct hda_verb[]) {
14935                         /* Enables internal speaker */
14936                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
14937                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14938                         {}
14939                 }
14940         },
14941         [ALC269_FIXUP_SKU_IGNORE] = {
14942                 .type = ALC_FIXUP_SKU,
14943                 .v.sku = ALC_FIXUP_SKU_IGNORE,
14944         },
14945         [ALC269_FIXUP_ASUS_G73JW] = {
14946                 .type = ALC_FIXUP_PINS,
14947                 .v.pins = (const struct alc_pincfg[]) {
14948                         { 0x17, 0x99130111 }, /* subwoofer */
14949                         { }
14950                 }
14951         },
14952         [ALC269_FIXUP_LENOVO_EAPD] = {
14953                 .type = ALC_FIXUP_VERBS,
14954                 .v.verbs = (const struct hda_verb[]) {
14955                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
14956                         {}
14957                 }
14958         },
14959         [ALC275_FIXUP_SONY_HWEQ] = {
14960                 .type = ALC_FIXUP_FUNC,
14961                 .v.func = alc269_fixup_hweq,
14962                 .chained = true,
14963                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
14964         },
14965         [ALC271_FIXUP_DMIC] = {
14966                 .type = ALC_FIXUP_FUNC,
14967                 .v.func = alc271_fixup_dmic,
14968         },
14969 };
14970
14971 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
14972         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
14973         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14974         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14975         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14976         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14977         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
14978         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14979         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
14980         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14981         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
14982         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
14983         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14984         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
14985         {}
14986 };
14987
14988
14989 /*
14990  * configuration and preset
14991  */
14992 static const char * const alc269_models[ALC269_MODEL_LAST] = {
14993         [ALC269_BASIC]                  = "basic",
14994         [ALC269_QUANTA_FL1]             = "quanta",
14995         [ALC269_AMIC]                   = "laptop-amic",
14996         [ALC269_DMIC]                   = "laptop-dmic",
14997         [ALC269_FUJITSU]                = "fujitsu",
14998         [ALC269_LIFEBOOK]               = "lifebook",
14999         [ALC269_AUTO]                   = "auto",
15000 };
15001
15002 static const struct snd_pci_quirk alc269_cfg_tbl[] = {
15003         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
15004         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
15005         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
15006                       ALC269_AMIC),
15007         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
15008         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
15009         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
15010         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
15011         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
15012         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
15013         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
15014         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
15015         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
15016         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269VB_AMIC),
15017         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
15018         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
15019         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
15020         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
15021         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
15022         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
15023         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
15024         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
15025         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
15026         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
15027         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
15028         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
15029         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
15030         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
15031         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
15032         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
15033         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
15034         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
15035         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
15036         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
15037         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
15038         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
15039         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
15040         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
15041         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
15042         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
15043         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
15044                       ALC269_DMIC),
15045         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
15046                       ALC269_DMIC),
15047         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
15048         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
15049         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
15050         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
15051         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
15052         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
15053         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
15054         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
15055         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
15056         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
15057         {}
15058 };
15059
15060 static const struct alc_config_preset alc269_presets[] = {
15061         [ALC269_BASIC] = {
15062                 .mixers = { alc269_base_mixer },
15063                 .init_verbs = { alc269_init_verbs },
15064                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15065                 .dac_nids = alc269_dac_nids,
15066                 .hp_nid = 0x03,
15067                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15068                 .channel_mode = alc269_modes,
15069                 .input_mux = &alc269_capture_source,
15070         },
15071         [ALC269_QUANTA_FL1] = {
15072                 .mixers = { alc269_quanta_fl1_mixer },
15073                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
15074                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15075                 .dac_nids = alc269_dac_nids,
15076                 .hp_nid = 0x03,
15077                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15078                 .channel_mode = alc269_modes,
15079                 .input_mux = &alc269_capture_source,
15080                 .unsol_event = alc269_quanta_fl1_unsol_event,
15081                 .setup = alc269_quanta_fl1_setup,
15082                 .init_hook = alc269_quanta_fl1_init_hook,
15083         },
15084         [ALC269_AMIC] = {
15085                 .mixers = { alc269_laptop_mixer },
15086                 .cap_mixer = alc269_laptop_analog_capture_mixer,
15087                 .init_verbs = { alc269_init_verbs,
15088                                 alc269_laptop_amic_init_verbs },
15089                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15090                 .dac_nids = alc269_dac_nids,
15091                 .hp_nid = 0x03,
15092                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15093                 .channel_mode = alc269_modes,
15094                 .unsol_event = alc_sku_unsol_event,
15095                 .setup = alc269_laptop_amic_setup,
15096                 .init_hook = alc_inithook,
15097         },
15098         [ALC269_DMIC] = {
15099                 .mixers = { alc269_laptop_mixer },
15100                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15101                 .init_verbs = { alc269_init_verbs,
15102                                 alc269_laptop_dmic_init_verbs },
15103                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15104                 .dac_nids = alc269_dac_nids,
15105                 .hp_nid = 0x03,
15106                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15107                 .channel_mode = alc269_modes,
15108                 .unsol_event = alc_sku_unsol_event,
15109                 .setup = alc269_laptop_dmic_setup,
15110                 .init_hook = alc_inithook,
15111         },
15112         [ALC269VB_AMIC] = {
15113                 .mixers = { alc269vb_laptop_mixer },
15114                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
15115                 .init_verbs = { alc269vb_init_verbs,
15116                                 alc269vb_laptop_amic_init_verbs },
15117                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15118                 .dac_nids = alc269_dac_nids,
15119                 .hp_nid = 0x03,
15120                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15121                 .channel_mode = alc269_modes,
15122                 .unsol_event = alc_sku_unsol_event,
15123                 .setup = alc269vb_laptop_amic_setup,
15124                 .init_hook = alc_inithook,
15125         },
15126         [ALC269VB_DMIC] = {
15127                 .mixers = { alc269vb_laptop_mixer },
15128                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15129                 .init_verbs = { alc269vb_init_verbs,
15130                                 alc269vb_laptop_dmic_init_verbs },
15131                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15132                 .dac_nids = alc269_dac_nids,
15133                 .hp_nid = 0x03,
15134                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15135                 .channel_mode = alc269_modes,
15136                 .unsol_event = alc_sku_unsol_event,
15137                 .setup = alc269vb_laptop_dmic_setup,
15138                 .init_hook = alc_inithook,
15139         },
15140         [ALC269_FUJITSU] = {
15141                 .mixers = { alc269_fujitsu_mixer },
15142                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15143                 .init_verbs = { alc269_init_verbs,
15144                                 alc269_laptop_dmic_init_verbs },
15145                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15146                 .dac_nids = alc269_dac_nids,
15147                 .hp_nid = 0x03,
15148                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15149                 .channel_mode = alc269_modes,
15150                 .unsol_event = alc_sku_unsol_event,
15151                 .setup = alc269_laptop_dmic_setup,
15152                 .init_hook = alc_inithook,
15153         },
15154         [ALC269_LIFEBOOK] = {
15155                 .mixers = { alc269_lifebook_mixer },
15156                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15157                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15158                 .dac_nids = alc269_dac_nids,
15159                 .hp_nid = 0x03,
15160                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15161                 .channel_mode = alc269_modes,
15162                 .input_mux = &alc269_capture_source,
15163                 .unsol_event = alc269_lifebook_unsol_event,
15164                 .setup = alc269_lifebook_setup,
15165                 .init_hook = alc269_lifebook_init_hook,
15166         },
15167         [ALC271_ACER] = {
15168                 .mixers = { alc269_asus_mixer },
15169                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15170                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15171                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15172                 .dac_nids = alc269_dac_nids,
15173                 .adc_nids = alc262_dmic_adc_nids,
15174                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15175                 .capsrc_nids = alc262_dmic_capsrc_nids,
15176                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15177                 .channel_mode = alc269_modes,
15178                 .input_mux = &alc269_capture_source,
15179                 .dig_out_nid = ALC880_DIGOUT_NID,
15180                 .unsol_event = alc_sku_unsol_event,
15181                 .setup = alc269vb_laptop_dmic_setup,
15182                 .init_hook = alc_inithook,
15183         },
15184 };
15185
15186 static int alc269_fill_coef(struct hda_codec *codec)
15187 {
15188         int val;
15189
15190         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15191                 alc_write_coef_idx(codec, 0xf, 0x960b);
15192                 alc_write_coef_idx(codec, 0xe, 0x8817);
15193         }
15194
15195         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15196                 alc_write_coef_idx(codec, 0xf, 0x960b);
15197                 alc_write_coef_idx(codec, 0xe, 0x8814);
15198         }
15199
15200         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15201                 val = alc_read_coef_idx(codec, 0x04);
15202                 /* Power up output pin */
15203                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15204         }
15205
15206         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15207                 val = alc_read_coef_idx(codec, 0xd);
15208                 if ((val & 0x0c00) >> 10 != 0x1) {
15209                         /* Capless ramp up clock control */
15210                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
15211                 }
15212                 val = alc_read_coef_idx(codec, 0x17);
15213                 if ((val & 0x01c0) >> 6 != 0x4) {
15214                         /* Class D power on reset */
15215                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
15216                 }
15217         }
15218
15219         val = alc_read_coef_idx(codec, 0xd); /* Class D */
15220         alc_write_coef_idx(codec, 0xd, val | (1<<14));
15221
15222         val = alc_read_coef_idx(codec, 0x4); /* HP */
15223         alc_write_coef_idx(codec, 0x4, val | (1<<11));
15224
15225         return 0;
15226 }
15227
15228 static int patch_alc269(struct hda_codec *codec)
15229 {
15230         struct alc_spec *spec;
15231         int board_config, coef;
15232         int err;
15233
15234         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15235         if (spec == NULL)
15236                 return -ENOMEM;
15237
15238         codec->spec = spec;
15239
15240         alc_auto_parse_customize_define(codec);
15241
15242         if (codec->vendor_id == 0x10ec0269) {
15243                 coef = alc_read_coef_idx(codec, 0);
15244                 if ((coef & 0x00f0) == 0x0010) {
15245                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15246                             spec->cdefine.platform_type == 1) {
15247                                 alc_codec_rename(codec, "ALC271X");
15248                                 spec->codec_variant = ALC269_TYPE_ALC271X;
15249                         } else if ((coef & 0xf000) == 0x1000) {
15250                                 spec->codec_variant = ALC269_TYPE_ALC270;
15251                         } else if ((coef & 0xf000) == 0x2000) {
15252                                 alc_codec_rename(codec, "ALC259");
15253                                 spec->codec_variant = ALC269_TYPE_ALC259;
15254                         } else if ((coef & 0xf000) == 0x3000) {
15255                                 alc_codec_rename(codec, "ALC258");
15256                                 spec->codec_variant = ALC269_TYPE_ALC258;
15257                         } else {
15258                                 alc_codec_rename(codec, "ALC269VB");
15259                                 spec->codec_variant = ALC269_TYPE_ALC269VB;
15260                         }
15261                 } else
15262                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
15263                 alc269_fill_coef(codec);
15264         }
15265
15266         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15267                                                   alc269_models,
15268                                                   alc269_cfg_tbl);
15269
15270         if (board_config < 0) {
15271                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15272                        codec->chip_name);
15273                 board_config = ALC269_AUTO;
15274         }
15275
15276         if (board_config == ALC269_AUTO) {
15277                 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
15278                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
15279         }
15280
15281         if (board_config == ALC269_AUTO) {
15282                 /* automatic parse from the BIOS config */
15283                 err = alc269_parse_auto_config(codec);
15284                 if (err < 0) {
15285                         alc_free(codec);
15286                         return err;
15287                 } else if (!err) {
15288                         printk(KERN_INFO
15289                                "hda_codec: Cannot set up configuration "
15290                                "from BIOS.  Using base mode...\n");
15291                         board_config = ALC269_BASIC;
15292                 }
15293         }
15294
15295         if (has_cdefine_beep(codec)) {
15296                 err = snd_hda_attach_beep_device(codec, 0x1);
15297                 if (err < 0) {
15298                         alc_free(codec);
15299                         return err;
15300                 }
15301         }
15302
15303         if (board_config != ALC269_AUTO)
15304                 setup_preset(codec, &alc269_presets[board_config]);
15305
15306         if (board_config == ALC269_QUANTA_FL1) {
15307                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15308                  * fix the sample rate of analog I/O to 44.1kHz
15309                  */
15310                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15311                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15312         } else if (spec->dual_adc_switch) {
15313                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15314                 /* switch ADC dynamically */
15315                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15316         } else {
15317                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15318                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15319         }
15320         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15321         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15322
15323         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15324                 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15325                         spec->adc_nids = alc269_adc_nids;
15326                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15327                         spec->capsrc_nids = alc269_capsrc_nids;
15328                 } else {
15329                         spec->adc_nids = alc269vb_adc_nids;
15330                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15331                         spec->capsrc_nids = alc269vb_capsrc_nids;
15332                 }
15333         }
15334
15335         if (!spec->cap_mixer)
15336                 set_capture_mixer(codec);
15337         if (has_cdefine_beep(codec))
15338                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15339
15340         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
15341
15342         spec->vmaster_nid = 0x02;
15343
15344         codec->patch_ops = alc_patch_ops;
15345 #ifdef SND_HDA_NEEDS_RESUME
15346         codec->patch_ops.resume = alc269_resume;
15347 #endif
15348         if (board_config == ALC269_AUTO)
15349                 spec->init_hook = alc269_auto_init;
15350         spec->shutup = alc269_shutup;
15351
15352         alc_init_jacks(codec);
15353 #ifdef CONFIG_SND_HDA_POWER_SAVE
15354         if (!spec->loopback.amplist)
15355                 spec->loopback.amplist = alc269_loopbacks;
15356         if (alc269_mic2_for_mute_led(codec))
15357                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15358 #endif
15359
15360         return 0;
15361 }
15362
15363 /*
15364  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15365  */
15366
15367 /*
15368  * set the path ways for 2 channel output
15369  * need to set the codec line out and mic 1 pin widgets to inputs
15370  */
15371 static const struct hda_verb alc861_threestack_ch2_init[] = {
15372         /* set pin widget 1Ah (line in) for input */
15373         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15374         /* set pin widget 18h (mic1/2) for input, for mic also enable
15375          * the vref
15376          */
15377         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15378
15379         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15380 #if 0
15381         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15382         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15383 #endif
15384         { } /* end */
15385 };
15386 /*
15387  * 6ch mode
15388  * need to set the codec line out and mic 1 pin widgets to outputs
15389  */
15390 static const struct hda_verb alc861_threestack_ch6_init[] = {
15391         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15392         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15393         /* set pin widget 18h (mic1) for output (CLFE)*/
15394         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15395
15396         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15397         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15398
15399         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15400 #if 0
15401         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15402         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15403 #endif
15404         { } /* end */
15405 };
15406
15407 static const struct hda_channel_mode alc861_threestack_modes[2] = {
15408         { 2, alc861_threestack_ch2_init },
15409         { 6, alc861_threestack_ch6_init },
15410 };
15411 /* Set mic1 as input and unmute the mixer */
15412 static const struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15413         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15414         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15415         { } /* end */
15416 };
15417 /* Set mic1 as output and mute mixer */
15418 static const struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15419         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15420         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15421         { } /* end */
15422 };
15423
15424 static const struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15425         { 2, alc861_uniwill_m31_ch2_init },
15426         { 4, alc861_uniwill_m31_ch4_init },
15427 };
15428
15429 /* Set mic1 and line-in as input and unmute the mixer */
15430 static const struct hda_verb alc861_asus_ch2_init[] = {
15431         /* set pin widget 1Ah (line in) for input */
15432         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15433         /* set pin widget 18h (mic1/2) for input, for mic also enable
15434          * the vref
15435          */
15436         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15437
15438         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15439 #if 0
15440         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15441         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15442 #endif
15443         { } /* end */
15444 };
15445 /* Set mic1 nad line-in as output and mute mixer */
15446 static const struct hda_verb alc861_asus_ch6_init[] = {
15447         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15448         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15449         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15450         /* set pin widget 18h (mic1) for output (CLFE)*/
15451         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15452         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15453         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15454         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15455
15456         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15457 #if 0
15458         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15459         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15460 #endif
15461         { } /* end */
15462 };
15463
15464 static const struct hda_channel_mode alc861_asus_modes[2] = {
15465         { 2, alc861_asus_ch2_init },
15466         { 6, alc861_asus_ch6_init },
15467 };
15468
15469 /* patch-ALC861 */
15470
15471 static const struct snd_kcontrol_new alc861_base_mixer[] = {
15472         /* output mixer control */
15473         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15474         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15475         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15476         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15477         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15478
15479         /*Input mixer control */
15480         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15481            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15482         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15483         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15484         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15485         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15486         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15487         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15488         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15489         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15490
15491         { } /* end */
15492 };
15493
15494 static const struct snd_kcontrol_new alc861_3ST_mixer[] = {
15495         /* output mixer control */
15496         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15497         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15498         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15499         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15500         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15501
15502         /* Input mixer control */
15503         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15504            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15505         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15506         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15507         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15508         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15509         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15510         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15511         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15512         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15513
15514         {
15515                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15516                 .name = "Channel Mode",
15517                 .info = alc_ch_mode_info,
15518                 .get = alc_ch_mode_get,
15519                 .put = alc_ch_mode_put,
15520                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15521         },
15522         { } /* end */
15523 };
15524
15525 static const struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15526         /* output mixer control */
15527         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15528         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15529         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15530
15531         { } /* end */
15532 };
15533
15534 static const struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15535         /* output mixer control */
15536         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15537         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15538         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15539         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15540         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15541
15542         /* Input mixer control */
15543         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15544            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15545         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15546         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15547         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15548         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15549         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15550         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15551         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15552         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15553
15554         {
15555                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15556                 .name = "Channel Mode",
15557                 .info = alc_ch_mode_info,
15558                 .get = alc_ch_mode_get,
15559                 .put = alc_ch_mode_put,
15560                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15561         },
15562         { } /* end */
15563 };
15564
15565 static const struct snd_kcontrol_new alc861_asus_mixer[] = {
15566         /* output mixer control */
15567         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15568         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15569         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15570         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15571         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15572
15573         /* Input mixer control */
15574         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15575         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15576         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15577         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15578         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15579         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15580         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15581         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15582         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15583         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15584
15585         {
15586                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15587                 .name = "Channel Mode",
15588                 .info = alc_ch_mode_info,
15589                 .get = alc_ch_mode_get,
15590                 .put = alc_ch_mode_put,
15591                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15592         },
15593         { }
15594 };
15595
15596 /* additional mixer */
15597 static const struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15598         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15599         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15600         { }
15601 };
15602
15603 /*
15604  * generic initialization of ADC, input mixers and output mixers
15605  */
15606 static const struct hda_verb alc861_base_init_verbs[] = {
15607         /*
15608          * Unmute ADC0 and set the default input to mic-in
15609          */
15610         /* port-A for surround (rear panel) */
15611         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15612         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15613         /* port-B for mic-in (rear panel) with vref */
15614         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15615         /* port-C for line-in (rear panel) */
15616         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15617         /* port-D for Front */
15618         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15619         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15620         /* port-E for HP out (front panel) */
15621         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15622         /* route front PCM to HP */
15623         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15624         /* port-F for mic-in (front panel) with vref */
15625         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15626         /* port-G for CLFE (rear panel) */
15627         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15628         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15629         /* port-H for side (rear panel) */
15630         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15631         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15632         /* CD-in */
15633         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15634         /* route front mic to ADC1*/
15635         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15636         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15637
15638         /* Unmute DAC0~3 & spdif out*/
15639         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15640         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15641         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15642         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15643         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15644
15645         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15646         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15647         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15648         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15649         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15650
15651         /* Unmute Stereo Mixer 15 */
15652         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15653         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15654         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15655         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15656
15657         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15658         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15659         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15660         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15661         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15662         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15663         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15664         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15665         /* hp used DAC 3 (Front) */
15666         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15667         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15668
15669         { }
15670 };
15671
15672 static const struct hda_verb alc861_threestack_init_verbs[] = {
15673         /*
15674          * Unmute ADC0 and set the default input to mic-in
15675          */
15676         /* port-A for surround (rear panel) */
15677         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15678         /* port-B for mic-in (rear panel) with vref */
15679         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15680         /* port-C for line-in (rear panel) */
15681         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15682         /* port-D for Front */
15683         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15684         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15685         /* port-E for HP out (front panel) */
15686         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15687         /* route front PCM to HP */
15688         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15689         /* port-F for mic-in (front panel) with vref */
15690         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15691         /* port-G for CLFE (rear panel) */
15692         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15693         /* port-H for side (rear panel) */
15694         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15695         /* CD-in */
15696         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15697         /* route front mic to ADC1*/
15698         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15699         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15700         /* Unmute DAC0~3 & spdif out*/
15701         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15702         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15703         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15704         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15705         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15706
15707         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15708         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15709         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15710         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15711         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15712
15713         /* Unmute Stereo Mixer 15 */
15714         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15715         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15716         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15717         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15718
15719         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15720         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15721         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15722         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15723         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15724         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15725         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15726         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15727         /* hp used DAC 3 (Front) */
15728         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15729         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15730         { }
15731 };
15732
15733 static const struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15734         /*
15735          * Unmute ADC0 and set the default input to mic-in
15736          */
15737         /* port-A for surround (rear panel) */
15738         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15739         /* port-B for mic-in (rear panel) with vref */
15740         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15741         /* port-C for line-in (rear panel) */
15742         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15743         /* port-D for Front */
15744         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15745         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15746         /* port-E for HP out (front panel) */
15747         /* this has to be set to VREF80 */
15748         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15749         /* route front PCM to HP */
15750         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15751         /* port-F for mic-in (front panel) with vref */
15752         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15753         /* port-G for CLFE (rear panel) */
15754         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15755         /* port-H for side (rear panel) */
15756         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15757         /* CD-in */
15758         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15759         /* route front mic to ADC1*/
15760         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15761         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15762         /* Unmute DAC0~3 & spdif out*/
15763         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15764         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15765         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15766         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15767         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15768
15769         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15770         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15771         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15772         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15773         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15774
15775         /* Unmute Stereo Mixer 15 */
15776         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15777         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15778         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15779         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15780
15781         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15782         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15783         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15784         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15785         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15786         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15787         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15788         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15789         /* hp used DAC 3 (Front) */
15790         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15791         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15792         { }
15793 };
15794
15795 static const struct hda_verb alc861_asus_init_verbs[] = {
15796         /*
15797          * Unmute ADC0 and set the default input to mic-in
15798          */
15799         /* port-A for surround (rear panel)
15800          * according to codec#0 this is the HP jack
15801          */
15802         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15803         /* route front PCM to HP */
15804         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15805         /* port-B for mic-in (rear panel) with vref */
15806         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15807         /* port-C for line-in (rear panel) */
15808         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15809         /* port-D for Front */
15810         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15811         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15812         /* port-E for HP out (front panel) */
15813         /* this has to be set to VREF80 */
15814         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15815         /* route front PCM to HP */
15816         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15817         /* port-F for mic-in (front panel) with vref */
15818         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15819         /* port-G for CLFE (rear panel) */
15820         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15821         /* port-H for side (rear panel) */
15822         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15823         /* CD-in */
15824         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15825         /* route front mic to ADC1*/
15826         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15827         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15828         /* Unmute DAC0~3 & spdif out*/
15829         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15830         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15831         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15832         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15833         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15834         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15835         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15836         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15837         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15838         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15839
15840         /* Unmute Stereo Mixer 15 */
15841         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15842         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15843         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15844         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15845
15846         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15847         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15848         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15849         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15850         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15851         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15852         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15853         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15854         /* hp used DAC 3 (Front) */
15855         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15856         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15857         { }
15858 };
15859
15860 /* additional init verbs for ASUS laptops */
15861 static const struct hda_verb alc861_asus_laptop_init_verbs[] = {
15862         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15863         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15864         { }
15865 };
15866
15867 /*
15868  * generic initialization of ADC, input mixers and output mixers
15869  */
15870 static const struct hda_verb alc861_auto_init_verbs[] = {
15871         /*
15872          * Unmute ADC0 and set the default input to mic-in
15873          */
15874         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15875         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15876
15877         /* Unmute DAC0~3 & spdif out*/
15878         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15879         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15880         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15881         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15882         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15883
15884         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15885         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15886         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15887         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15888         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15889
15890         /* Unmute Stereo Mixer 15 */
15891         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15892         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15893         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15894         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15895
15896         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15897         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15898         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15899         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15900         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15901         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15902         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15903         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15904
15905         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15906         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15907         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15908         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15909         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15910         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15911         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15912         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15913
15914         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15915
15916         { }
15917 };
15918
15919 static const struct hda_verb alc861_toshiba_init_verbs[] = {
15920         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15921
15922         { }
15923 };
15924
15925 /* toggle speaker-output according to the hp-jack state */
15926 static void alc861_toshiba_automute(struct hda_codec *codec)
15927 {
15928         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15929
15930         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15931                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15932         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15933                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15934 }
15935
15936 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15937                                        unsigned int res)
15938 {
15939         if ((res >> 26) == ALC880_HP_EVENT)
15940                 alc861_toshiba_automute(codec);
15941 }
15942
15943 /* pcm configuration: identical with ALC880 */
15944 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15945 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15946 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15947 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15948
15949
15950 #define ALC861_DIGOUT_NID       0x07
15951
15952 static const struct hda_channel_mode alc861_8ch_modes[1] = {
15953         { 8, NULL }
15954 };
15955
15956 static const hda_nid_t alc861_dac_nids[4] = {
15957         /* front, surround, clfe, side */
15958         0x03, 0x06, 0x05, 0x04
15959 };
15960
15961 static const hda_nid_t alc660_dac_nids[3] = {
15962         /* front, clfe, surround */
15963         0x03, 0x05, 0x06
15964 };
15965
15966 static const hda_nid_t alc861_adc_nids[1] = {
15967         /* ADC0-2 */
15968         0x08,
15969 };
15970
15971 static const struct hda_input_mux alc861_capture_source = {
15972         .num_items = 5,
15973         .items = {
15974                 { "Mic", 0x0 },
15975                 { "Front Mic", 0x3 },
15976                 { "Line", 0x1 },
15977                 { "CD", 0x4 },
15978                 { "Mixer", 0x5 },
15979         },
15980 };
15981
15982 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15983 {
15984         struct alc_spec *spec = codec->spec;
15985         hda_nid_t mix, srcs[5];
15986         int i, j, num;
15987
15988         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15989                 return 0;
15990         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15991         if (num < 0)
15992                 return 0;
15993         for (i = 0; i < num; i++) {
15994                 unsigned int type;
15995                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15996                 if (type != AC_WID_AUD_OUT)
15997                         continue;
15998                 for (j = 0; j < spec->multiout.num_dacs; j++)
15999                         if (spec->multiout.dac_nids[j] == srcs[i])
16000                                 break;
16001                 if (j >= spec->multiout.num_dacs)
16002                         return srcs[i];
16003         }
16004         return 0;
16005 }
16006
16007 /* fill in the dac_nids table from the parsed pin configuration */
16008 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
16009                                      const struct auto_pin_cfg *cfg)
16010 {
16011         struct alc_spec *spec = codec->spec;
16012         int i;
16013         hda_nid_t nid, dac;
16014
16015         spec->multiout.dac_nids = spec->private_dac_nids;
16016         for (i = 0; i < cfg->line_outs; i++) {
16017                 nid = cfg->line_out_pins[i];
16018                 dac = alc861_look_for_dac(codec, nid);
16019                 if (!dac)
16020                         continue;
16021                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
16022         }
16023         return 0;
16024 }
16025
16026 static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
16027                                   hda_nid_t nid, int idx, unsigned int chs)
16028 {
16029         return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
16030                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
16031 }
16032
16033 #define alc861_create_out_sw(codec, pfx, nid, chs) \
16034         __alc861_create_out_sw(codec, pfx, nid, 0, chs)
16035
16036 /* add playback controls from the parsed DAC table */
16037 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
16038                                              const struct auto_pin_cfg *cfg)
16039 {
16040         struct alc_spec *spec = codec->spec;
16041         hda_nid_t nid;
16042         int i, err, noutputs;
16043
16044         noutputs = cfg->line_outs;
16045         if (spec->multi_ios > 0)
16046                 noutputs += spec->multi_ios;
16047
16048         for (i = 0; i < noutputs; i++) {
16049                 const char *name;
16050                 int index;
16051                 nid = spec->multiout.dac_nids[i];
16052                 if (!nid)
16053                         continue;
16054                 name = alc_get_line_out_pfx(spec, i, true, &index);
16055                 if (!name) {
16056                         /* Center/LFE */
16057                         err = alc861_create_out_sw(codec, "Center", nid, 1);
16058                         if (err < 0)
16059                                 return err;
16060                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
16061                         if (err < 0)
16062                                 return err;
16063                 } else {
16064                         err = __alc861_create_out_sw(codec, name, nid, index, 3);
16065                         if (err < 0)
16066                                 return err;
16067                 }
16068         }
16069         return 0;
16070 }
16071
16072 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
16073 {
16074         struct alc_spec *spec = codec->spec;
16075         int err;
16076         hda_nid_t nid;
16077
16078         if (!pin)
16079                 return 0;
16080
16081         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
16082                 nid = alc861_look_for_dac(codec, pin);
16083                 if (nid) {
16084                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
16085                         if (err < 0)
16086                                 return err;
16087                         spec->multiout.hp_nid = nid;
16088                 }
16089         }
16090         return 0;
16091 }
16092
16093 /* create playback/capture controls for input pins */
16094 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
16095                                                 const struct auto_pin_cfg *cfg)
16096 {
16097         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
16098 }
16099
16100 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
16101                                               hda_nid_t nid,
16102                                               int pin_type, hda_nid_t dac)
16103 {
16104         hda_nid_t mix, srcs[5];
16105         int i, num;
16106
16107         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
16108                             pin_type);
16109         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16110                             AMP_OUT_UNMUTE);
16111         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
16112                 return;
16113         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
16114         if (num < 0)
16115                 return;
16116         for (i = 0; i < num; i++) {
16117                 unsigned int mute;
16118                 if (srcs[i] == dac || srcs[i] == 0x15)
16119                         mute = AMP_IN_UNMUTE(i);
16120                 else
16121                         mute = AMP_IN_MUTE(i);
16122                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16123                                     mute);
16124         }
16125 }
16126
16127 static void alc861_auto_init_multi_out(struct hda_codec *codec)
16128 {
16129         struct alc_spec *spec = codec->spec;
16130         int i;
16131
16132         for (i = 0; i < spec->autocfg.line_outs; i++) {
16133                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16134                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16135                 if (nid)
16136                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
16137                                                           spec->multiout.dac_nids[i]);
16138         }
16139 }
16140
16141 static void alc861_auto_init_hp_out(struct hda_codec *codec)
16142 {
16143         struct alc_spec *spec = codec->spec;
16144
16145         if (spec->autocfg.hp_outs)
16146                 alc861_auto_set_output_and_unmute(codec,
16147                                                   spec->autocfg.hp_pins[0],
16148                                                   PIN_HP,
16149                                                   spec->multiout.hp_nid);
16150         if (spec->autocfg.speaker_outs)
16151                 alc861_auto_set_output_and_unmute(codec,
16152                                                   spec->autocfg.speaker_pins[0],
16153                                                   PIN_OUT,
16154                                                   spec->multiout.dac_nids[0]);
16155 }
16156
16157 static void alc861_auto_init_analog_input(struct hda_codec *codec)
16158 {
16159         struct alc_spec *spec = codec->spec;
16160         struct auto_pin_cfg *cfg = &spec->autocfg;
16161         int i;
16162
16163         for (i = 0; i < cfg->num_inputs; i++) {
16164                 hda_nid_t nid = cfg->inputs[i].pin;
16165                 if (nid >= 0x0c && nid <= 0x11)
16166                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16167         }
16168 }
16169
16170 /* parse the BIOS configuration and set up the alc_spec */
16171 /* return 1 if successful, 0 if the proper config is not found,
16172  * or a negative error code
16173  */
16174 static int alc861_parse_auto_config(struct hda_codec *codec)
16175 {
16176         struct alc_spec *spec = codec->spec;
16177         int err;
16178         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16179
16180         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16181                                            alc861_ignore);
16182         if (err < 0)
16183                 return err;
16184         if (!spec->autocfg.line_outs)
16185                 return 0; /* can't find valid BIOS pin config */
16186
16187         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16188         if (err < 0)
16189                 return err;
16190         err = alc_auto_add_multi_channel_mode(codec);
16191         if (err < 0)
16192                 return err;
16193         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16194         if (err < 0)
16195                 return err;
16196         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16197         if (err < 0)
16198                 return err;
16199         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16200         if (err < 0)
16201                 return err;
16202
16203         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16204
16205         alc_auto_parse_digital(codec);
16206
16207         if (spec->kctls.list)
16208                 add_mixer(spec, spec->kctls.list);
16209
16210         add_verb(spec, alc861_auto_init_verbs);
16211
16212         spec->num_mux_defs = 1;
16213         spec->input_mux = &spec->private_imux[0];
16214
16215         spec->adc_nids = alc861_adc_nids;
16216         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16217         set_capture_mixer(codec);
16218
16219         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16220
16221         return 1;
16222 }
16223
16224 /* additional initialization for auto-configuration model */
16225 static void alc861_auto_init(struct hda_codec *codec)
16226 {
16227         struct alc_spec *spec = codec->spec;
16228         alc861_auto_init_multi_out(codec);
16229         alc861_auto_init_hp_out(codec);
16230         alc861_auto_init_analog_input(codec);
16231         alc_auto_init_digital(codec);
16232         if (spec->unsol_event)
16233                 alc_inithook(codec);
16234 }
16235
16236 #ifdef CONFIG_SND_HDA_POWER_SAVE
16237 static const struct hda_amp_list alc861_loopbacks[] = {
16238         { 0x15, HDA_INPUT, 0 },
16239         { 0x15, HDA_INPUT, 1 },
16240         { 0x15, HDA_INPUT, 2 },
16241         { 0x15, HDA_INPUT, 3 },
16242         { } /* end */
16243 };
16244 #endif
16245
16246
16247 /*
16248  * configuration and preset
16249  */
16250 static const char * const alc861_models[ALC861_MODEL_LAST] = {
16251         [ALC861_3ST]            = "3stack",
16252         [ALC660_3ST]            = "3stack-660",
16253         [ALC861_3ST_DIG]        = "3stack-dig",
16254         [ALC861_6ST_DIG]        = "6stack-dig",
16255         [ALC861_UNIWILL_M31]    = "uniwill-m31",
16256         [ALC861_TOSHIBA]        = "toshiba",
16257         [ALC861_ASUS]           = "asus",
16258         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
16259         [ALC861_AUTO]           = "auto",
16260 };
16261
16262 static const struct snd_pci_quirk alc861_cfg_tbl[] = {
16263         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16264         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16265         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16266         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16267         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16268         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16269         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16270         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16271          *        Any other models that need this preset?
16272          */
16273         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16274         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16275         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16276         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16277         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16278         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16279         /* FIXME: the below seems conflict */
16280         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16281         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16282         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16283         {}
16284 };
16285
16286 static const struct alc_config_preset alc861_presets[] = {
16287         [ALC861_3ST] = {
16288                 .mixers = { alc861_3ST_mixer },
16289                 .init_verbs = { alc861_threestack_init_verbs },
16290                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16291                 .dac_nids = alc861_dac_nids,
16292                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16293                 .channel_mode = alc861_threestack_modes,
16294                 .need_dac_fix = 1,
16295                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16296                 .adc_nids = alc861_adc_nids,
16297                 .input_mux = &alc861_capture_source,
16298         },
16299         [ALC861_3ST_DIG] = {
16300                 .mixers = { alc861_base_mixer },
16301                 .init_verbs = { alc861_threestack_init_verbs },
16302                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16303                 .dac_nids = alc861_dac_nids,
16304                 .dig_out_nid = ALC861_DIGOUT_NID,
16305                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16306                 .channel_mode = alc861_threestack_modes,
16307                 .need_dac_fix = 1,
16308                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16309                 .adc_nids = alc861_adc_nids,
16310                 .input_mux = &alc861_capture_source,
16311         },
16312         [ALC861_6ST_DIG] = {
16313                 .mixers = { alc861_base_mixer },
16314                 .init_verbs = { alc861_base_init_verbs },
16315                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16316                 .dac_nids = alc861_dac_nids,
16317                 .dig_out_nid = ALC861_DIGOUT_NID,
16318                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16319                 .channel_mode = alc861_8ch_modes,
16320                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16321                 .adc_nids = alc861_adc_nids,
16322                 .input_mux = &alc861_capture_source,
16323         },
16324         [ALC660_3ST] = {
16325                 .mixers = { alc861_3ST_mixer },
16326                 .init_verbs = { alc861_threestack_init_verbs },
16327                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16328                 .dac_nids = alc660_dac_nids,
16329                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16330                 .channel_mode = alc861_threestack_modes,
16331                 .need_dac_fix = 1,
16332                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16333                 .adc_nids = alc861_adc_nids,
16334                 .input_mux = &alc861_capture_source,
16335         },
16336         [ALC861_UNIWILL_M31] = {
16337                 .mixers = { alc861_uniwill_m31_mixer },
16338                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16339                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16340                 .dac_nids = alc861_dac_nids,
16341                 .dig_out_nid = ALC861_DIGOUT_NID,
16342                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16343                 .channel_mode = alc861_uniwill_m31_modes,
16344                 .need_dac_fix = 1,
16345                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16346                 .adc_nids = alc861_adc_nids,
16347                 .input_mux = &alc861_capture_source,
16348         },
16349         [ALC861_TOSHIBA] = {
16350                 .mixers = { alc861_toshiba_mixer },
16351                 .init_verbs = { alc861_base_init_verbs,
16352                                 alc861_toshiba_init_verbs },
16353                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16354                 .dac_nids = alc861_dac_nids,
16355                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16356                 .channel_mode = alc883_3ST_2ch_modes,
16357                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16358                 .adc_nids = alc861_adc_nids,
16359                 .input_mux = &alc861_capture_source,
16360                 .unsol_event = alc861_toshiba_unsol_event,
16361                 .init_hook = alc861_toshiba_automute,
16362         },
16363         [ALC861_ASUS] = {
16364                 .mixers = { alc861_asus_mixer },
16365                 .init_verbs = { alc861_asus_init_verbs },
16366                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16367                 .dac_nids = alc861_dac_nids,
16368                 .dig_out_nid = ALC861_DIGOUT_NID,
16369                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16370                 .channel_mode = alc861_asus_modes,
16371                 .need_dac_fix = 1,
16372                 .hp_nid = 0x06,
16373                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16374                 .adc_nids = alc861_adc_nids,
16375                 .input_mux = &alc861_capture_source,
16376         },
16377         [ALC861_ASUS_LAPTOP] = {
16378                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16379                 .init_verbs = { alc861_asus_init_verbs,
16380                                 alc861_asus_laptop_init_verbs },
16381                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16382                 .dac_nids = alc861_dac_nids,
16383                 .dig_out_nid = ALC861_DIGOUT_NID,
16384                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16385                 .channel_mode = alc883_3ST_2ch_modes,
16386                 .need_dac_fix = 1,
16387                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16388                 .adc_nids = alc861_adc_nids,
16389                 .input_mux = &alc861_capture_source,
16390         },
16391 };
16392
16393 /* Pin config fixes */
16394 enum {
16395         PINFIX_FSC_AMILO_PI1505,
16396 };
16397
16398 static const struct alc_fixup alc861_fixups[] = {
16399         [PINFIX_FSC_AMILO_PI1505] = {
16400                 .type = ALC_FIXUP_PINS,
16401                 .v.pins = (const struct alc_pincfg[]) {
16402                         { 0x0b, 0x0221101f }, /* HP */
16403                         { 0x0f, 0x90170310 }, /* speaker */
16404                         { }
16405                 }
16406         },
16407 };
16408
16409 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
16410         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16411         {}
16412 };
16413
16414 static int patch_alc861(struct hda_codec *codec)
16415 {
16416         struct alc_spec *spec;
16417         int board_config;
16418         int err;
16419
16420         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16421         if (spec == NULL)
16422                 return -ENOMEM;
16423
16424         codec->spec = spec;
16425
16426         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16427                                                   alc861_models,
16428                                                   alc861_cfg_tbl);
16429
16430         if (board_config < 0) {
16431                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16432                        codec->chip_name);
16433                 board_config = ALC861_AUTO;
16434         }
16435
16436         if (board_config == ALC861_AUTO) {
16437                 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
16438                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
16439         }
16440
16441         if (board_config == ALC861_AUTO) {
16442                 /* automatic parse from the BIOS config */
16443                 err = alc861_parse_auto_config(codec);
16444                 if (err < 0) {
16445                         alc_free(codec);
16446                         return err;
16447                 } else if (!err) {
16448                         printk(KERN_INFO
16449                                "hda_codec: Cannot set up configuration "
16450                                "from BIOS.  Using base mode...\n");
16451                    board_config = ALC861_3ST_DIG;
16452                 }
16453         }
16454
16455         err = snd_hda_attach_beep_device(codec, 0x23);
16456         if (err < 0) {
16457                 alc_free(codec);
16458                 return err;
16459         }
16460
16461         if (board_config != ALC861_AUTO)
16462                 setup_preset(codec, &alc861_presets[board_config]);
16463
16464         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16465         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16466
16467         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16468         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16469
16470         if (!spec->cap_mixer)
16471                 set_capture_mixer(codec);
16472         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16473
16474         spec->vmaster_nid = 0x03;
16475
16476         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
16477
16478         codec->patch_ops = alc_patch_ops;
16479         if (board_config == ALC861_AUTO) {
16480                 spec->init_hook = alc861_auto_init;
16481 #ifdef CONFIG_SND_HDA_POWER_SAVE
16482                 spec->power_hook = alc_power_eapd;
16483 #endif
16484         }
16485 #ifdef CONFIG_SND_HDA_POWER_SAVE
16486         if (!spec->loopback.amplist)
16487                 spec->loopback.amplist = alc861_loopbacks;
16488 #endif
16489
16490         return 0;
16491 }
16492
16493 /*
16494  * ALC861-VD support
16495  *
16496  * Based on ALC882
16497  *
16498  * In addition, an independent DAC
16499  */
16500 #define ALC861VD_DIGOUT_NID     0x06
16501
16502 static const hda_nid_t alc861vd_dac_nids[4] = {
16503         /* front, surr, clfe, side surr */
16504         0x02, 0x03, 0x04, 0x05
16505 };
16506
16507 /* dac_nids for ALC660vd are in a different order - according to
16508  * Realtek's driver.
16509  * This should probably result in a different mixer for 6stack models
16510  * of ALC660vd codecs, but for now there is only 3stack mixer
16511  * - and it is the same as in 861vd.
16512  * adc_nids in ALC660vd are (is) the same as in 861vd
16513  */
16514 static const hda_nid_t alc660vd_dac_nids[3] = {
16515         /* front, rear, clfe, rear_surr */
16516         0x02, 0x04, 0x03
16517 };
16518
16519 static const hda_nid_t alc861vd_adc_nids[1] = {
16520         /* ADC0 */
16521         0x09,
16522 };
16523
16524 static const hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16525
16526 /* input MUX */
16527 /* FIXME: should be a matrix-type input source selection */
16528 static const struct hda_input_mux alc861vd_capture_source = {
16529         .num_items = 4,
16530         .items = {
16531                 { "Mic", 0x0 },
16532                 { "Front Mic", 0x1 },
16533                 { "Line", 0x2 },
16534                 { "CD", 0x4 },
16535         },
16536 };
16537
16538 static const struct hda_input_mux alc861vd_dallas_capture_source = {
16539         .num_items = 2,
16540         .items = {
16541                 { "Mic", 0x0 },
16542                 { "Internal Mic", 0x1 },
16543         },
16544 };
16545
16546 static const struct hda_input_mux alc861vd_hp_capture_source = {
16547         .num_items = 2,
16548         .items = {
16549                 { "Front Mic", 0x0 },
16550                 { "ATAPI Mic", 0x1 },
16551         },
16552 };
16553
16554 /*
16555  * 2ch mode
16556  */
16557 static const struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16558         { 2, NULL }
16559 };
16560
16561 /*
16562  * 6ch mode
16563  */
16564 static const struct hda_verb alc861vd_6stack_ch6_init[] = {
16565         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16566         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16567         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16568         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16569         { } /* end */
16570 };
16571
16572 /*
16573  * 8ch mode
16574  */
16575 static const struct hda_verb alc861vd_6stack_ch8_init[] = {
16576         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16577         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16578         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16579         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16580         { } /* end */
16581 };
16582
16583 static const struct hda_channel_mode alc861vd_6stack_modes[2] = {
16584         { 6, alc861vd_6stack_ch6_init },
16585         { 8, alc861vd_6stack_ch8_init },
16586 };
16587
16588 static const struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16589         {
16590                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16591                 .name = "Channel Mode",
16592                 .info = alc_ch_mode_info,
16593                 .get = alc_ch_mode_get,
16594                 .put = alc_ch_mode_put,
16595         },
16596         { } /* end */
16597 };
16598
16599 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16600  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16601  */
16602 static const struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16603         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16604         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16605
16606         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16607         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16608
16609         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16610                                 HDA_OUTPUT),
16611         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16612                                 HDA_OUTPUT),
16613         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16614         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16615
16616         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16617         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16618
16619         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16620
16621         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16622         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16623         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16624
16625         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16626         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16627         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16628
16629         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16630         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16631
16632         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16633         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16634
16635         { } /* end */
16636 };
16637
16638 static const struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16639         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16640         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16641
16642         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16643
16644         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16645         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16646         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16647
16648         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16649         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16650         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16651
16652         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16653         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16654
16655         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16656         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16657
16658         { } /* end */
16659 };
16660
16661 static const struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16662         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16663         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16664         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16665
16666         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16667
16668         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16669         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16670         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16671
16672         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16673         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16674         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16675
16676         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16677         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16678
16679         { } /* end */
16680 };
16681
16682 /* Pin assignment: Speaker=0x14, HP = 0x15,
16683  *                 Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16684  */
16685 static const struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16686         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16687         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16688         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16689         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16690         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16691         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16692         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16693         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
16694         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16695         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16696         { } /* end */
16697 };
16698
16699 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16700  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16701  */
16702 static const struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16703         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16704         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16705         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16706         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16707         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16708         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16709         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16710         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16711
16712         { } /* end */
16713 };
16714
16715 /*
16716  * generic initialization of ADC, input mixers and output mixers
16717  */
16718 static const struct hda_verb alc861vd_volume_init_verbs[] = {
16719         /*
16720          * Unmute ADC0 and set the default input to mic-in
16721          */
16722         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16723         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16724
16725         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16726          * the analog-loopback mixer widget
16727          */
16728         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16729         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16730         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16731         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16732         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16733         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16734
16735         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16736         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16737         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16738         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16739         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16740
16741         /*
16742          * Set up output mixers (0x02 - 0x05)
16743          */
16744         /* set vol=0 to output mixers */
16745         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16746         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16747         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16748         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16749
16750         /* set up input amps for analog loopback */
16751         /* Amp Indices: DAC = 0, mixer = 1 */
16752         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16753         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16754         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16755         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16756         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16757         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16758         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16759         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16760
16761         { }
16762 };
16763
16764 /*
16765  * 3-stack pin configuration:
16766  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16767  */
16768 static const struct hda_verb alc861vd_3stack_init_verbs[] = {
16769         /*
16770          * Set pin mode and muting
16771          */
16772         /* set front pin widgets 0x14 for output */
16773         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16774         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16775         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16776
16777         /* Mic (rear) pin: input vref at 80% */
16778         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16779         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16780         /* Front Mic pin: input vref at 80% */
16781         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16782         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16783         /* Line In pin: input */
16784         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16785         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16786         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16787         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16788         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16789         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16790         /* CD pin widget for input */
16791         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16792
16793         { }
16794 };
16795
16796 /*
16797  * 6-stack pin configuration:
16798  */
16799 static const struct hda_verb alc861vd_6stack_init_verbs[] = {
16800         /*
16801          * Set pin mode and muting
16802          */
16803         /* set front pin widgets 0x14 for output */
16804         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16805         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16806         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16807
16808         /* Rear Pin: output 1 (0x0d) */
16809         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16810         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16811         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16812         /* CLFE Pin: output 2 (0x0e) */
16813         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16814         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16815         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16816         /* Side Pin: output 3 (0x0f) */
16817         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16818         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16819         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16820
16821         /* Mic (rear) pin: input vref at 80% */
16822         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16823         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16824         /* Front Mic pin: input vref at 80% */
16825         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16826         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16827         /* Line In pin: input */
16828         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16829         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16830         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16831         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16832         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16833         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16834         /* CD pin widget for input */
16835         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16836
16837         { }
16838 };
16839
16840 static const struct hda_verb alc861vd_eapd_verbs[] = {
16841         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16842         { }
16843 };
16844
16845 static const struct hda_verb alc660vd_eapd_verbs[] = {
16846         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16847         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16848         { }
16849 };
16850
16851 static const struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16852         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16853         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16854         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16855         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16856         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16857         {}
16858 };
16859
16860 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16861 {
16862         struct alc_spec *spec = codec->spec;
16863         spec->autocfg.hp_pins[0] = 0x1b;
16864         spec->autocfg.speaker_pins[0] = 0x14;
16865         spec->automute = 1;
16866         spec->automute_mode = ALC_AUTOMUTE_AMP;
16867 }
16868
16869 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16870 {
16871         alc_hp_automute(codec);
16872         alc88x_simple_mic_automute(codec);
16873 }
16874
16875 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16876                                         unsigned int res)
16877 {
16878         switch (res >> 26) {
16879         case ALC880_MIC_EVENT:
16880                 alc88x_simple_mic_automute(codec);
16881                 break;
16882         default:
16883                 alc_sku_unsol_event(codec, res);
16884                 break;
16885         }
16886 }
16887
16888 static const struct hda_verb alc861vd_dallas_verbs[] = {
16889         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16890         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16891         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16892         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16893
16894         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16895         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16896         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16897         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16898         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16899         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16900         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16901         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16902
16903         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16904         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16905         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16906         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16907         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16908         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16909         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16910         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16911
16912         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16913         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16914         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16915         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16916         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16917         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16918         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16919         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16920
16921         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16922         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16923         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16924         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16925
16926         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16927         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16928         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16929
16930         { } /* end */
16931 };
16932
16933 /* toggle speaker-output according to the hp-jack state */
16934 static void alc861vd_dallas_setup(struct hda_codec *codec)
16935 {
16936         struct alc_spec *spec = codec->spec;
16937
16938         spec->autocfg.hp_pins[0] = 0x15;
16939         spec->autocfg.speaker_pins[0] = 0x14;
16940         spec->automute = 1;
16941         spec->automute_mode = ALC_AUTOMUTE_AMP;
16942 }
16943
16944 #ifdef CONFIG_SND_HDA_POWER_SAVE
16945 #define alc861vd_loopbacks      alc880_loopbacks
16946 #endif
16947
16948 /* pcm configuration: identical with ALC880 */
16949 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16950 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16951 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16952 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16953
16954 /*
16955  * configuration and preset
16956  */
16957 static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = {
16958         [ALC660VD_3ST]          = "3stack-660",
16959         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16960         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16961         [ALC861VD_3ST]          = "3stack",
16962         [ALC861VD_3ST_DIG]      = "3stack-digout",
16963         [ALC861VD_6ST_DIG]      = "6stack-digout",
16964         [ALC861VD_LENOVO]       = "lenovo",
16965         [ALC861VD_DALLAS]       = "dallas",
16966         [ALC861VD_HP]           = "hp",
16967         [ALC861VD_AUTO]         = "auto",
16968 };
16969
16970 static const struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16971         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16972         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16973         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16974         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16975         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16976         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16977         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16978         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16979         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16980         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16981         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16982         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16983         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16984         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16985         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16986         {}
16987 };
16988
16989 static const struct alc_config_preset alc861vd_presets[] = {
16990         [ALC660VD_3ST] = {
16991                 .mixers = { alc861vd_3st_mixer },
16992                 .init_verbs = { alc861vd_volume_init_verbs,
16993                                  alc861vd_3stack_init_verbs },
16994                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16995                 .dac_nids = alc660vd_dac_nids,
16996                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16997                 .channel_mode = alc861vd_3stack_2ch_modes,
16998                 .input_mux = &alc861vd_capture_source,
16999         },
17000         [ALC660VD_3ST_DIG] = {
17001                 .mixers = { alc861vd_3st_mixer },
17002                 .init_verbs = { alc861vd_volume_init_verbs,
17003                                  alc861vd_3stack_init_verbs },
17004                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17005                 .dac_nids = alc660vd_dac_nids,
17006                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17007                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17008                 .channel_mode = alc861vd_3stack_2ch_modes,
17009                 .input_mux = &alc861vd_capture_source,
17010         },
17011         [ALC861VD_3ST] = {
17012                 .mixers = { alc861vd_3st_mixer },
17013                 .init_verbs = { alc861vd_volume_init_verbs,
17014                                  alc861vd_3stack_init_verbs },
17015                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17016                 .dac_nids = alc861vd_dac_nids,
17017                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17018                 .channel_mode = alc861vd_3stack_2ch_modes,
17019                 .input_mux = &alc861vd_capture_source,
17020         },
17021         [ALC861VD_3ST_DIG] = {
17022                 .mixers = { alc861vd_3st_mixer },
17023                 .init_verbs = { alc861vd_volume_init_verbs,
17024                                  alc861vd_3stack_init_verbs },
17025                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17026                 .dac_nids = alc861vd_dac_nids,
17027                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17028                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17029                 .channel_mode = alc861vd_3stack_2ch_modes,
17030                 .input_mux = &alc861vd_capture_source,
17031         },
17032         [ALC861VD_6ST_DIG] = {
17033                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
17034                 .init_verbs = { alc861vd_volume_init_verbs,
17035                                 alc861vd_6stack_init_verbs },
17036                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17037                 .dac_nids = alc861vd_dac_nids,
17038                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17039                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
17040                 .channel_mode = alc861vd_6stack_modes,
17041                 .input_mux = &alc861vd_capture_source,
17042         },
17043         [ALC861VD_LENOVO] = {
17044                 .mixers = { alc861vd_lenovo_mixer },
17045                 .init_verbs = { alc861vd_volume_init_verbs,
17046                                 alc861vd_3stack_init_verbs,
17047                                 alc861vd_eapd_verbs,
17048                                 alc861vd_lenovo_unsol_verbs },
17049                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17050                 .dac_nids = alc660vd_dac_nids,
17051                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17052                 .channel_mode = alc861vd_3stack_2ch_modes,
17053                 .input_mux = &alc861vd_capture_source,
17054                 .unsol_event = alc861vd_lenovo_unsol_event,
17055                 .setup = alc861vd_lenovo_setup,
17056                 .init_hook = alc861vd_lenovo_init_hook,
17057         },
17058         [ALC861VD_DALLAS] = {
17059                 .mixers = { alc861vd_dallas_mixer },
17060                 .init_verbs = { alc861vd_dallas_verbs },
17061                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17062                 .dac_nids = alc861vd_dac_nids,
17063                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17064                 .channel_mode = alc861vd_3stack_2ch_modes,
17065                 .input_mux = &alc861vd_dallas_capture_source,
17066                 .unsol_event = alc_sku_unsol_event,
17067                 .setup = alc861vd_dallas_setup,
17068                 .init_hook = alc_hp_automute,
17069         },
17070         [ALC861VD_HP] = {
17071                 .mixers = { alc861vd_hp_mixer },
17072                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
17073                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17074                 .dac_nids = alc861vd_dac_nids,
17075                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17076                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17077                 .channel_mode = alc861vd_3stack_2ch_modes,
17078                 .input_mux = &alc861vd_hp_capture_source,
17079                 .unsol_event = alc_sku_unsol_event,
17080                 .setup = alc861vd_dallas_setup,
17081                 .init_hook = alc_hp_automute,
17082         },
17083         [ALC660VD_ASUS_V1S] = {
17084                 .mixers = { alc861vd_lenovo_mixer },
17085                 .init_verbs = { alc861vd_volume_init_verbs,
17086                                 alc861vd_3stack_init_verbs,
17087                                 alc861vd_eapd_verbs,
17088                                 alc861vd_lenovo_unsol_verbs },
17089                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17090                 .dac_nids = alc660vd_dac_nids,
17091                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17092                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17093                 .channel_mode = alc861vd_3stack_2ch_modes,
17094                 .input_mux = &alc861vd_capture_source,
17095                 .unsol_event = alc861vd_lenovo_unsol_event,
17096                 .setup = alc861vd_lenovo_setup,
17097                 .init_hook = alc861vd_lenovo_init_hook,
17098         },
17099 };
17100
17101 /*
17102  * BIOS auto configuration
17103  */
17104 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
17105                                                 const struct auto_pin_cfg *cfg)
17106 {
17107         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
17108 }
17109
17110
17111 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
17112                                 hda_nid_t nid, int pin_type, int dac_idx)
17113 {
17114         alc_set_pin_output(codec, nid, pin_type);
17115 }
17116
17117 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
17118 {
17119         struct alc_spec *spec = codec->spec;
17120         int i;
17121
17122         for (i = 0; i <= HDA_SIDE; i++) {
17123                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17124                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17125                 if (nid)
17126                         alc861vd_auto_set_output_and_unmute(codec, nid,
17127                                                             pin_type, i);
17128         }
17129 }
17130
17131
17132 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17133 {
17134         struct alc_spec *spec = codec->spec;
17135         hda_nid_t pin;
17136
17137         pin = spec->autocfg.hp_pins[0];
17138         if (pin) /* connect to front and use dac 0 */
17139                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17140         pin = spec->autocfg.speaker_pins[0];
17141         if (pin)
17142                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17143 }
17144
17145 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
17146
17147 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17148 {
17149         struct alc_spec *spec = codec->spec;
17150         struct auto_pin_cfg *cfg = &spec->autocfg;
17151         int i;
17152
17153         for (i = 0; i < cfg->num_inputs; i++) {
17154                 hda_nid_t nid = cfg->inputs[i].pin;
17155                 if (alc_is_input_pin(codec, nid)) {
17156                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17157                         if (nid != ALC861VD_PIN_CD_NID &&
17158                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17159                                 snd_hda_codec_write(codec, nid, 0,
17160                                                 AC_VERB_SET_AMP_GAIN_MUTE,
17161                                                 AMP_OUT_MUTE);
17162                 }
17163         }
17164 }
17165
17166 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
17167
17168 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
17169 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
17170
17171 /* add playback controls from the parsed DAC table */
17172 /* Based on ALC880 version. But ALC861VD has separate,
17173  * different NIDs for mute/unmute switch and volume control */
17174 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17175                                              const struct auto_pin_cfg *cfg)
17176 {
17177         hda_nid_t nid_v, nid_s;
17178         int i, err, noutputs;
17179
17180         noutputs = cfg->line_outs;
17181         if (spec->multi_ios > 0)
17182                 noutputs += spec->multi_ios;
17183
17184         for (i = 0; i < noutputs; i++) {
17185                 const char *name;
17186                 int index;
17187                 if (!spec->multiout.dac_nids[i])
17188                         continue;
17189                 nid_v = alc861vd_idx_to_mixer_vol(
17190                                 alc880_dac_to_idx(
17191                                         spec->multiout.dac_nids[i]));
17192                 nid_s = alc861vd_idx_to_mixer_switch(
17193                                 alc880_dac_to_idx(
17194                                         spec->multiout.dac_nids[i]));
17195
17196                 name = alc_get_line_out_pfx(spec, i, true, &index);
17197                 if (!name) {
17198                         /* Center/LFE */
17199                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17200                                               "Center",
17201                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17202                                                               HDA_OUTPUT));
17203                         if (err < 0)
17204                                 return err;
17205                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17206                                               "LFE",
17207                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17208                                                               HDA_OUTPUT));
17209                         if (err < 0)
17210                                 return err;
17211                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17212                                              "Center",
17213                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17214                                                               HDA_INPUT));
17215                         if (err < 0)
17216                                 return err;
17217                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17218                                              "LFE",
17219                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17220                                                               HDA_INPUT));
17221                         if (err < 0)
17222                                 return err;
17223                 } else {
17224                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17225                                                 name, index,
17226                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17227                                                               HDA_OUTPUT));
17228                         if (err < 0)
17229                                 return err;
17230                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17231                                                name, index,
17232                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17233                                                               HDA_INPUT));
17234                         if (err < 0)
17235                                 return err;
17236                 }
17237         }
17238         return 0;
17239 }
17240
17241 /* add playback controls for speaker and HP outputs */
17242 /* Based on ALC880 version. But ALC861VD has separate,
17243  * different NIDs for mute/unmute switch and volume control */
17244 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17245                                         hda_nid_t pin, const char *pfx)
17246 {
17247         hda_nid_t nid_v, nid_s;
17248         int err;
17249
17250         if (!pin)
17251                 return 0;
17252
17253         if (alc880_is_fixed_pin(pin)) {
17254                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17255                 /* specify the DAC as the extra output */
17256                 if (!spec->multiout.hp_nid)
17257                         spec->multiout.hp_nid = nid_v;
17258                 else
17259                         spec->multiout.extra_out_nid[0] = nid_v;
17260                 /* control HP volume/switch on the output mixer amp */
17261                 nid_v = alc861vd_idx_to_mixer_vol(
17262                                 alc880_fixed_pin_idx(pin));
17263                 nid_s = alc861vd_idx_to_mixer_switch(
17264                                 alc880_fixed_pin_idx(pin));
17265
17266                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17267                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17268                 if (err < 0)
17269                         return err;
17270                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17271                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17272                 if (err < 0)
17273                         return err;
17274         } else if (alc880_is_multi_pin(pin)) {
17275                 /* set manual connection */
17276                 /* we have only a switch on HP-out PIN */
17277                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17278                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17279                 if (err < 0)
17280                         return err;
17281         }
17282         return 0;
17283 }
17284
17285 /* parse the BIOS configuration and set up the alc_spec
17286  * return 1 if successful, 0 if the proper config is not found,
17287  * or a negative error code
17288  * Based on ALC880 version - had to change it to override
17289  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17290 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17291 {
17292         struct alc_spec *spec = codec->spec;
17293         int err;
17294         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17295
17296         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17297                                            alc861vd_ignore);
17298         if (err < 0)
17299                 return err;
17300         if (!spec->autocfg.line_outs)
17301                 return 0; /* can't find valid BIOS pin config */
17302
17303         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17304         if (err < 0)
17305                 return err;
17306         err = alc_auto_add_multi_channel_mode(codec);
17307         if (err < 0)
17308                 return err;
17309         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17310         if (err < 0)
17311                 return err;
17312         err = alc861vd_auto_create_extra_out(spec,
17313                                              spec->autocfg.speaker_pins[0],
17314                                              "Speaker");
17315         if (err < 0)
17316                 return err;
17317         err = alc861vd_auto_create_extra_out(spec,
17318                                              spec->autocfg.hp_pins[0],
17319                                              "Headphone");
17320         if (err < 0)
17321                 return err;
17322         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17323         if (err < 0)
17324                 return err;
17325
17326         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17327
17328         alc_auto_parse_digital(codec);
17329
17330         if (spec->kctls.list)
17331                 add_mixer(spec, spec->kctls.list);
17332
17333         add_verb(spec, alc861vd_volume_init_verbs);
17334
17335         spec->num_mux_defs = 1;
17336         spec->input_mux = &spec->private_imux[0];
17337
17338         err = alc_auto_add_mic_boost(codec);
17339         if (err < 0)
17340                 return err;
17341
17342         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17343
17344         return 1;
17345 }
17346
17347 /* additional initialization for auto-configuration model */
17348 static void alc861vd_auto_init(struct hda_codec *codec)
17349 {
17350         struct alc_spec *spec = codec->spec;
17351         alc861vd_auto_init_multi_out(codec);
17352         alc861vd_auto_init_hp_out(codec);
17353         alc861vd_auto_init_analog_input(codec);
17354         alc861vd_auto_init_input_src(codec);
17355         alc_auto_init_digital(codec);
17356         if (spec->unsol_event)
17357                 alc_inithook(codec);
17358 }
17359
17360 enum {
17361         ALC660VD_FIX_ASUS_GPIO1
17362 };
17363
17364 /* reset GPIO1 */
17365 static const struct alc_fixup alc861vd_fixups[] = {
17366         [ALC660VD_FIX_ASUS_GPIO1] = {
17367                 .type = ALC_FIXUP_VERBS,
17368                 .v.verbs = (const struct hda_verb[]) {
17369                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17370                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17371                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17372                         { }
17373                 }
17374         },
17375 };
17376
17377 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17378         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17379         {}
17380 };
17381
17382 static int patch_alc861vd(struct hda_codec *codec)
17383 {
17384         struct alc_spec *spec;
17385         int err, board_config;
17386
17387         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17388         if (spec == NULL)
17389                 return -ENOMEM;
17390
17391         codec->spec = spec;
17392
17393         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17394                                                   alc861vd_models,
17395                                                   alc861vd_cfg_tbl);
17396
17397         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17398                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17399                        codec->chip_name);
17400                 board_config = ALC861VD_AUTO;
17401         }
17402
17403         if (board_config == ALC861VD_AUTO) {
17404                 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
17405                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
17406         }
17407
17408         if (board_config == ALC861VD_AUTO) {
17409                 /* automatic parse from the BIOS config */
17410                 err = alc861vd_parse_auto_config(codec);
17411                 if (err < 0) {
17412                         alc_free(codec);
17413                         return err;
17414                 } else if (!err) {
17415                         printk(KERN_INFO
17416                                "hda_codec: Cannot set up configuration "
17417                                "from BIOS.  Using base mode...\n");
17418                         board_config = ALC861VD_3ST;
17419                 }
17420         }
17421
17422         err = snd_hda_attach_beep_device(codec, 0x23);
17423         if (err < 0) {
17424                 alc_free(codec);
17425                 return err;
17426         }
17427
17428         if (board_config != ALC861VD_AUTO)
17429                 setup_preset(codec, &alc861vd_presets[board_config]);
17430
17431         if (codec->vendor_id == 0x10ec0660) {
17432                 /* always turn on EAPD */
17433                 add_verb(spec, alc660vd_eapd_verbs);
17434         }
17435
17436         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17437         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17438
17439         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17440         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17441
17442         if (!spec->adc_nids) {
17443                 spec->adc_nids = alc861vd_adc_nids;
17444                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17445         }
17446         if (!spec->capsrc_nids)
17447                 spec->capsrc_nids = alc861vd_capsrc_nids;
17448
17449         set_capture_mixer(codec);
17450         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17451
17452         spec->vmaster_nid = 0x02;
17453
17454         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
17455
17456         codec->patch_ops = alc_patch_ops;
17457
17458         if (board_config == ALC861VD_AUTO)
17459                 spec->init_hook = alc861vd_auto_init;
17460         spec->shutup = alc_eapd_shutup;
17461 #ifdef CONFIG_SND_HDA_POWER_SAVE
17462         if (!spec->loopback.amplist)
17463                 spec->loopback.amplist = alc861vd_loopbacks;
17464 #endif
17465
17466         return 0;
17467 }
17468
17469 /*
17470  * ALC662 support
17471  *
17472  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17473  * configuration.  Each pin widget can choose any input DACs and a mixer.
17474  * Each ADC is connected from a mixer of all inputs.  This makes possible
17475  * 6-channel independent captures.
17476  *
17477  * In addition, an independent DAC for the multi-playback (not used in this
17478  * driver yet).
17479  */
17480 #define ALC662_DIGOUT_NID       0x06
17481 #define ALC662_DIGIN_NID        0x0a
17482
17483 static const hda_nid_t alc662_dac_nids[3] = {
17484         /* front, rear, clfe */
17485         0x02, 0x03, 0x04
17486 };
17487
17488 static const hda_nid_t alc272_dac_nids[2] = {
17489         0x02, 0x03
17490 };
17491
17492 static const hda_nid_t alc662_adc_nids[2] = {
17493         /* ADC1-2 */
17494         0x09, 0x08
17495 };
17496
17497 static const hda_nid_t alc272_adc_nids[1] = {
17498         /* ADC1-2 */
17499         0x08,
17500 };
17501
17502 static const hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17503 static const hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17504
17505
17506 /* input MUX */
17507 /* FIXME: should be a matrix-type input source selection */
17508 static const struct hda_input_mux alc662_capture_source = {
17509         .num_items = 4,
17510         .items = {
17511                 { "Mic", 0x0 },
17512                 { "Front Mic", 0x1 },
17513                 { "Line", 0x2 },
17514                 { "CD", 0x4 },
17515         },
17516 };
17517
17518 static const struct hda_input_mux alc662_lenovo_101e_capture_source = {
17519         .num_items = 2,
17520         .items = {
17521                 { "Mic", 0x1 },
17522                 { "Line", 0x2 },
17523         },
17524 };
17525
17526 static const struct hda_input_mux alc663_capture_source = {
17527         .num_items = 3,
17528         .items = {
17529                 { "Mic", 0x0 },
17530                 { "Front Mic", 0x1 },
17531                 { "Line", 0x2 },
17532         },
17533 };
17534
17535 #if 0 /* set to 1 for testing other input sources below */
17536 static const struct hda_input_mux alc272_nc10_capture_source = {
17537         .num_items = 16,
17538         .items = {
17539                 { "Autoselect Mic", 0x0 },
17540                 { "Internal Mic", 0x1 },
17541                 { "In-0x02", 0x2 },
17542                 { "In-0x03", 0x3 },
17543                 { "In-0x04", 0x4 },
17544                 { "In-0x05", 0x5 },
17545                 { "In-0x06", 0x6 },
17546                 { "In-0x07", 0x7 },
17547                 { "In-0x08", 0x8 },
17548                 { "In-0x09", 0x9 },
17549                 { "In-0x0a", 0x0a },
17550                 { "In-0x0b", 0x0b },
17551                 { "In-0x0c", 0x0c },
17552                 { "In-0x0d", 0x0d },
17553                 { "In-0x0e", 0x0e },
17554                 { "In-0x0f", 0x0f },
17555         },
17556 };
17557 #endif
17558
17559 /*
17560  * 2ch mode
17561  */
17562 static const struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17563         { 2, NULL }
17564 };
17565
17566 /*
17567  * 2ch mode
17568  */
17569 static const struct hda_verb alc662_3ST_ch2_init[] = {
17570         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17571         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17572         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17573         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17574         { } /* end */
17575 };
17576
17577 /*
17578  * 6ch mode
17579  */
17580 static const struct hda_verb alc662_3ST_ch6_init[] = {
17581         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17582         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17583         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17584         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17585         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17586         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17587         { } /* end */
17588 };
17589
17590 static const struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17591         { 2, alc662_3ST_ch2_init },
17592         { 6, alc662_3ST_ch6_init },
17593 };
17594
17595 /*
17596  * 2ch mode
17597  */
17598 static const struct hda_verb alc662_sixstack_ch6_init[] = {
17599         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17600         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17601         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17602         { } /* end */
17603 };
17604
17605 /*
17606  * 6ch mode
17607  */
17608 static const struct hda_verb alc662_sixstack_ch8_init[] = {
17609         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17610         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17611         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17612         { } /* end */
17613 };
17614
17615 static const struct hda_channel_mode alc662_5stack_modes[2] = {
17616         { 2, alc662_sixstack_ch6_init },
17617         { 6, alc662_sixstack_ch8_init },
17618 };
17619
17620 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17621  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17622  */
17623
17624 static const struct snd_kcontrol_new alc662_base_mixer[] = {
17625         /* output mixer control */
17626         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17627         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17628         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17629         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17630         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17631         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17632         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17633         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17634         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17635
17636         /*Input mixer control */
17637         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17638         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17639         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17640         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17641         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17642         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17643         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17644         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17645         { } /* end */
17646 };
17647
17648 static const struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17649         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17650         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17651         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17652         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17653         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17654         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17655         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17656         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17657         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17658         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17659         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17660         { } /* end */
17661 };
17662
17663 static const struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17664         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17665         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17666         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17667         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17668         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17669         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17670         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17671         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17672         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17673         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17674         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17675         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17676         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17677         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17678         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17679         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17680         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17681         { } /* end */
17682 };
17683
17684 static const struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17685         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17686         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17687         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17688         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17689         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17690         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17691         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17692         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17693         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17694         { } /* end */
17695 };
17696
17697 static const struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17698         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17699         ALC262_HIPPO_MASTER_SWITCH,
17700
17701         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
17702         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17703         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17704
17705         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
17706         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17707         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17708         { } /* end */
17709 };
17710
17711 static const struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17712         ALC262_HIPPO_MASTER_SWITCH,
17713         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17714         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17715         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17716         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17717         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17718         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17719         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17720         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17721         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17722         { } /* end */
17723 };
17724
17725 static const struct hda_bind_ctls alc663_asus_bind_master_vol = {
17726         .ops = &snd_hda_bind_vol,
17727         .values = {
17728                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17729                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17730                 0
17731         },
17732 };
17733
17734 static const struct hda_bind_ctls alc663_asus_one_bind_switch = {
17735         .ops = &snd_hda_bind_sw,
17736         .values = {
17737                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17738                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17739                 0
17740         },
17741 };
17742
17743 static const struct snd_kcontrol_new alc663_m51va_mixer[] = {
17744         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17745         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17746         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17747         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17748         { } /* end */
17749 };
17750
17751 static const struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17752         .ops = &snd_hda_bind_sw,
17753         .values = {
17754                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17755                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17756                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17757                 0
17758         },
17759 };
17760
17761 static const struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17762         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17763         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17764         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17765         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17766         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17767         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17768
17769         { } /* end */
17770 };
17771
17772 static const struct hda_bind_ctls alc663_asus_four_bind_switch = {
17773         .ops = &snd_hda_bind_sw,
17774         .values = {
17775                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17776                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17777                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17778                 0
17779         },
17780 };
17781
17782 static const struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17783         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17784         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17785         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17786         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17787         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17788         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17789         { } /* end */
17790 };
17791
17792 static const struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17793         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17794         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17795         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17796         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17797         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17798         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17799         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17800         { } /* end */
17801 };
17802
17803 static const struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17804         .ops = &snd_hda_bind_vol,
17805         .values = {
17806                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17807                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17808                 0
17809         },
17810 };
17811
17812 static const struct hda_bind_ctls alc663_asus_two_bind_switch = {
17813         .ops = &snd_hda_bind_sw,
17814         .values = {
17815                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17816                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17817                 0
17818         },
17819 };
17820
17821 static const struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17822         HDA_BIND_VOL("Master Playback Volume",
17823                                 &alc663_asus_two_bind_master_vol),
17824         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17825         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17826         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17827         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17828         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17829         { } /* end */
17830 };
17831
17832 static const struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17833         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17834         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17835         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17836         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17837         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17838         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17839         { } /* end */
17840 };
17841
17842 static const struct snd_kcontrol_new alc663_g71v_mixer[] = {
17843         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17844         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17845         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17846         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17847         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17848
17849         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17850         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17851         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17852         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17853         { } /* end */
17854 };
17855
17856 static const struct snd_kcontrol_new alc663_g50v_mixer[] = {
17857         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17858         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17859         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17860
17861         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17862         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17863         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17864         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17865         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17866         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17867         { } /* end */
17868 };
17869
17870 static const struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17871         .ops = &snd_hda_bind_sw,
17872         .values = {
17873                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17874                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17875                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17876                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17877                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17878                 0
17879         },
17880 };
17881
17882 static const struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17883         .ops = &snd_hda_bind_sw,
17884         .values = {
17885                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17886                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17887                 0
17888         },
17889 };
17890
17891 static const struct snd_kcontrol_new alc663_mode7_mixer[] = {
17892         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17893         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17894         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17895         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17896         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17897         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17898         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17899         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17900         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17901         { } /* end */
17902 };
17903
17904 static const struct snd_kcontrol_new alc663_mode8_mixer[] = {
17905         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17906         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17907         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17908         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17909         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17910         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17911         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17912         { } /* end */
17913 };
17914
17915
17916 static const struct snd_kcontrol_new alc662_chmode_mixer[] = {
17917         {
17918                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17919                 .name = "Channel Mode",
17920                 .info = alc_ch_mode_info,
17921                 .get = alc_ch_mode_get,
17922                 .put = alc_ch_mode_put,
17923         },
17924         { } /* end */
17925 };
17926
17927 static const struct hda_verb alc662_init_verbs[] = {
17928         /* ADC: mute amp left and right */
17929         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17930         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17931
17932         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17933         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17934         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17935         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17936         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17937         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17938
17939         /* Front Pin: output 0 (0x0c) */
17940         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17941         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17942
17943         /* Rear Pin: output 1 (0x0d) */
17944         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17945         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17946
17947         /* CLFE Pin: output 2 (0x0e) */
17948         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17949         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17950
17951         /* Mic (rear) pin: input vref at 80% */
17952         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17953         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17954         /* Front Mic pin: input vref at 80% */
17955         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17956         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17957         /* Line In pin: input */
17958         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17959         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17960         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17961         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17962         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17963         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17964         /* CD pin widget for input */
17965         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17966
17967         /* FIXME: use matrix-type input source selection */
17968         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17969         /* Input mixer */
17970         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17971         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17972
17973         { }
17974 };
17975
17976 static const struct hda_verb alc662_eapd_init_verbs[] = {
17977         /* always trun on EAPD */
17978         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17979         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17980         { }
17981 };
17982
17983 static const struct hda_verb alc662_sue_init_verbs[] = {
17984         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17985         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17986         {}
17987 };
17988
17989 static const struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17990         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17991         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17992         {}
17993 };
17994
17995 /* Set Unsolicited Event*/
17996 static const struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17997         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17998         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17999         {}
18000 };
18001
18002 static const struct hda_verb alc663_m51va_init_verbs[] = {
18003         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18004         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18005         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18006         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18007         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18008         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18009         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18010         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18011         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18012         {}
18013 };
18014
18015 static const struct hda_verb alc663_21jd_amic_init_verbs[] = {
18016         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18017         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18018         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18019         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18021         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18022         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18023         {}
18024 };
18025
18026 static const struct hda_verb alc662_1bjd_amic_init_verbs[] = {
18027         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18028         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18029         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18030         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18031         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18032         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18033         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18034         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18035         {}
18036 };
18037
18038 static const struct hda_verb alc663_15jd_amic_init_verbs[] = {
18039         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18040         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18041         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18042         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18043         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18044         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18045         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18046         {}
18047 };
18048
18049 static const struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
18050         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18051         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18052         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18053         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18054         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18055         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18056         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18057         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18058         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18059         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18060         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18061         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18062         {}
18063 };
18064
18065 static const struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
18066         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18067         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18068         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18069         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18070         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18071         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18072         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18073         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18074         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18075         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18076         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18077         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18078         {}
18079 };
18080
18081 static const struct hda_verb alc663_g71v_init_verbs[] = {
18082         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18083         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
18084         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
18085
18086         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18087         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18088         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18089
18090         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
18091         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
18092         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
18093         {}
18094 };
18095
18096 static const struct hda_verb alc663_g50v_init_verbs[] = {
18097         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18098         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18099         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18100
18101         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18102         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18103         {}
18104 };
18105
18106 static const struct hda_verb alc662_ecs_init_verbs[] = {
18107         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
18108         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18109         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18110         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18111         {}
18112 };
18113
18114 static const struct hda_verb alc272_dell_zm1_init_verbs[] = {
18115         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18116         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18117         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18118         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18119         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18120         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18121         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18122         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18123         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18124         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18125         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18126         {}
18127 };
18128
18129 static const struct hda_verb alc272_dell_init_verbs[] = {
18130         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18131         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18132         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18133         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18134         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18135         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18136         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18137         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18138         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18139         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18140         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18141         {}
18142 };
18143
18144 static const struct hda_verb alc663_mode7_init_verbs[] = {
18145         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18146         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18147         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18148         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18149         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18150         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18151         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18152         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18153         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18154         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18155         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18156         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18157         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18158         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18159         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18160         {}
18161 };
18162
18163 static const struct hda_verb alc663_mode8_init_verbs[] = {
18164         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18165         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18166         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18167         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18168         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18169         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18170         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18171         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18172         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18173         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18174         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18175         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18176         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18177         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18178         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18179         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18180         {}
18181 };
18182
18183 static const struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18184         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18185         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18186         { } /* end */
18187 };
18188
18189 static const struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18190         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18191         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18192         { } /* end */
18193 };
18194
18195 static void alc662_lenovo_101e_setup(struct hda_codec *codec)
18196 {
18197         struct alc_spec *spec = codec->spec;
18198
18199         spec->autocfg.hp_pins[0] = 0x1b;
18200         spec->autocfg.line_out_pins[0] = 0x14;
18201         spec->autocfg.speaker_pins[0] = 0x15;
18202         spec->automute = 1;
18203         spec->detect_line = 1;
18204         spec->automute_lines = 1;
18205         spec->automute_mode = ALC_AUTOMUTE_AMP;
18206 }
18207
18208 static void alc662_eeepc_setup(struct hda_codec *codec)
18209 {
18210         struct alc_spec *spec = codec->spec;
18211
18212         alc262_hippo1_setup(codec);
18213         spec->ext_mic.pin = 0x18;
18214         spec->ext_mic.mux_idx = 0;
18215         spec->int_mic.pin = 0x19;
18216         spec->int_mic.mux_idx = 1;
18217         spec->auto_mic = 1;
18218 }
18219
18220 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18221 {
18222         struct alc_spec *spec = codec->spec;
18223
18224         spec->autocfg.hp_pins[0] = 0x14;
18225         spec->autocfg.speaker_pins[0] = 0x1b;
18226         spec->automute = 1;
18227         spec->automute_mode = ALC_AUTOMUTE_AMP;
18228 }
18229
18230 static void alc663_m51va_setup(struct hda_codec *codec)
18231 {
18232         struct alc_spec *spec = codec->spec;
18233         spec->autocfg.hp_pins[0] = 0x21;
18234         spec->autocfg.speaker_pins[0] = 0x14;
18235         spec->automute_mixer_nid[0] = 0x0c;
18236         spec->automute = 1;
18237         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18238         spec->ext_mic.pin = 0x18;
18239         spec->ext_mic.mux_idx = 0;
18240         spec->int_mic.pin = 0x12;
18241         spec->int_mic.mux_idx = 9;
18242         spec->auto_mic = 1;
18243 }
18244
18245 /* ***************** Mode1 ******************************/
18246 static void alc663_mode1_setup(struct hda_codec *codec)
18247 {
18248         struct alc_spec *spec = codec->spec;
18249         spec->autocfg.hp_pins[0] = 0x21;
18250         spec->autocfg.speaker_pins[0] = 0x14;
18251         spec->automute_mixer_nid[0] = 0x0c;
18252         spec->automute = 1;
18253         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18254         spec->ext_mic.pin = 0x18;
18255         spec->ext_mic.mux_idx = 0;
18256         spec->int_mic.pin = 0x19;
18257         spec->int_mic.mux_idx = 1;
18258         spec->auto_mic = 1;
18259 }
18260
18261 /* ***************** Mode2 ******************************/
18262 static void alc662_mode2_setup(struct hda_codec *codec)
18263 {
18264         struct alc_spec *spec = codec->spec;
18265         spec->autocfg.hp_pins[0] = 0x1b;
18266         spec->autocfg.speaker_pins[0] = 0x14;
18267         spec->automute = 1;
18268         spec->automute_mode = ALC_AUTOMUTE_PIN;
18269         spec->ext_mic.pin = 0x18;
18270         spec->ext_mic.mux_idx = 0;
18271         spec->int_mic.pin = 0x19;
18272         spec->int_mic.mux_idx = 1;
18273         spec->auto_mic = 1;
18274 }
18275
18276 /* ***************** Mode3 ******************************/
18277 static void alc663_mode3_setup(struct hda_codec *codec)
18278 {
18279         struct alc_spec *spec = codec->spec;
18280         spec->autocfg.hp_pins[0] = 0x21;
18281         spec->autocfg.hp_pins[0] = 0x15;
18282         spec->autocfg.speaker_pins[0] = 0x14;
18283         spec->automute = 1;
18284         spec->automute_mode = ALC_AUTOMUTE_PIN;
18285         spec->ext_mic.pin = 0x18;
18286         spec->ext_mic.mux_idx = 0;
18287         spec->int_mic.pin = 0x19;
18288         spec->int_mic.mux_idx = 1;
18289         spec->auto_mic = 1;
18290 }
18291
18292 /* ***************** Mode4 ******************************/
18293 static void alc663_mode4_setup(struct hda_codec *codec)
18294 {
18295         struct alc_spec *spec = codec->spec;
18296         spec->autocfg.hp_pins[0] = 0x21;
18297         spec->autocfg.speaker_pins[0] = 0x14;
18298         spec->autocfg.speaker_pins[1] = 0x16;
18299         spec->automute_mixer_nid[0] = 0x0c;
18300         spec->automute_mixer_nid[1] = 0x0e;
18301         spec->automute = 1;
18302         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18303         spec->ext_mic.pin = 0x18;
18304         spec->ext_mic.mux_idx = 0;
18305         spec->int_mic.pin = 0x19;
18306         spec->int_mic.mux_idx = 1;
18307         spec->auto_mic = 1;
18308 }
18309
18310 /* ***************** Mode5 ******************************/
18311 static void alc663_mode5_setup(struct hda_codec *codec)
18312 {
18313         struct alc_spec *spec = codec->spec;
18314         spec->autocfg.hp_pins[0] = 0x15;
18315         spec->autocfg.speaker_pins[0] = 0x14;
18316         spec->autocfg.speaker_pins[1] = 0x16;
18317         spec->automute_mixer_nid[0] = 0x0c;
18318         spec->automute_mixer_nid[1] = 0x0e;
18319         spec->automute = 1;
18320         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18321         spec->ext_mic.pin = 0x18;
18322         spec->ext_mic.mux_idx = 0;
18323         spec->int_mic.pin = 0x19;
18324         spec->int_mic.mux_idx = 1;
18325         spec->auto_mic = 1;
18326 }
18327
18328 /* ***************** Mode6 ******************************/
18329 static void alc663_mode6_setup(struct hda_codec *codec)
18330 {
18331         struct alc_spec *spec = codec->spec;
18332         spec->autocfg.hp_pins[0] = 0x1b;
18333         spec->autocfg.hp_pins[0] = 0x15;
18334         spec->autocfg.speaker_pins[0] = 0x14;
18335         spec->automute_mixer_nid[0] = 0x0c;
18336         spec->automute = 1;
18337         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18338         spec->ext_mic.pin = 0x18;
18339         spec->ext_mic.mux_idx = 0;
18340         spec->int_mic.pin = 0x19;
18341         spec->int_mic.mux_idx = 1;
18342         spec->auto_mic = 1;
18343 }
18344
18345 /* ***************** Mode7 ******************************/
18346 static void alc663_mode7_setup(struct hda_codec *codec)
18347 {
18348         struct alc_spec *spec = codec->spec;
18349         spec->autocfg.hp_pins[0] = 0x1b;
18350         spec->autocfg.hp_pins[0] = 0x21;
18351         spec->autocfg.speaker_pins[0] = 0x14;
18352         spec->autocfg.speaker_pins[0] = 0x17;
18353         spec->automute = 1;
18354         spec->automute_mode = ALC_AUTOMUTE_PIN;
18355         spec->ext_mic.pin = 0x18;
18356         spec->ext_mic.mux_idx = 0;
18357         spec->int_mic.pin = 0x19;
18358         spec->int_mic.mux_idx = 1;
18359         spec->auto_mic = 1;
18360 }
18361
18362 /* ***************** Mode8 ******************************/
18363 static void alc663_mode8_setup(struct hda_codec *codec)
18364 {
18365         struct alc_spec *spec = codec->spec;
18366         spec->autocfg.hp_pins[0] = 0x21;
18367         spec->autocfg.hp_pins[1] = 0x15;
18368         spec->autocfg.speaker_pins[0] = 0x14;
18369         spec->autocfg.speaker_pins[0] = 0x17;
18370         spec->automute = 1;
18371         spec->automute_mode = ALC_AUTOMUTE_PIN;
18372         spec->ext_mic.pin = 0x18;
18373         spec->ext_mic.mux_idx = 0;
18374         spec->int_mic.pin = 0x12;
18375         spec->int_mic.mux_idx = 9;
18376         spec->auto_mic = 1;
18377 }
18378
18379 static void alc663_g71v_setup(struct hda_codec *codec)
18380 {
18381         struct alc_spec *spec = codec->spec;
18382         spec->autocfg.hp_pins[0] = 0x21;
18383         spec->autocfg.line_out_pins[0] = 0x15;
18384         spec->autocfg.speaker_pins[0] = 0x14;
18385         spec->automute = 1;
18386         spec->automute_mode = ALC_AUTOMUTE_AMP;
18387         spec->detect_line = 1;
18388         spec->automute_lines = 1;
18389         spec->ext_mic.pin = 0x18;
18390         spec->ext_mic.mux_idx = 0;
18391         spec->int_mic.pin = 0x12;
18392         spec->int_mic.mux_idx = 9;
18393         spec->auto_mic = 1;
18394 }
18395
18396 #define alc663_g50v_setup       alc663_m51va_setup
18397
18398 static const struct snd_kcontrol_new alc662_ecs_mixer[] = {
18399         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18400         ALC262_HIPPO_MASTER_SWITCH,
18401
18402         HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT),
18403         HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18404         HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18405
18406         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18407         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18408         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18409         { } /* end */
18410 };
18411
18412 static const struct snd_kcontrol_new alc272_nc10_mixer[] = {
18413         /* Master Playback automatically created from Speaker and Headphone */
18414         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18415         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18416         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18417         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18418
18419         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18420         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18421         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
18422
18423         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18424         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18425         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18426         { } /* end */
18427 };
18428
18429 #ifdef CONFIG_SND_HDA_POWER_SAVE
18430 #define alc662_loopbacks        alc880_loopbacks
18431 #endif
18432
18433
18434 /* pcm configuration: identical with ALC880 */
18435 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18436 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18437 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18438 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18439
18440 /*
18441  * configuration and preset
18442  */
18443 static const char * const alc662_models[ALC662_MODEL_LAST] = {
18444         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18445         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18446         [ALC662_3ST_6ch]        = "3stack-6ch",
18447         [ALC662_5ST_DIG]        = "5stack-dig",
18448         [ALC662_LENOVO_101E]    = "lenovo-101e",
18449         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18450         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18451         [ALC662_ECS] = "ecs",
18452         [ALC663_ASUS_M51VA] = "m51va",
18453         [ALC663_ASUS_G71V] = "g71v",
18454         [ALC663_ASUS_H13] = "h13",
18455         [ALC663_ASUS_G50V] = "g50v",
18456         [ALC663_ASUS_MODE1] = "asus-mode1",
18457         [ALC662_ASUS_MODE2] = "asus-mode2",
18458         [ALC663_ASUS_MODE3] = "asus-mode3",
18459         [ALC663_ASUS_MODE4] = "asus-mode4",
18460         [ALC663_ASUS_MODE5] = "asus-mode5",
18461         [ALC663_ASUS_MODE6] = "asus-mode6",
18462         [ALC663_ASUS_MODE7] = "asus-mode7",
18463         [ALC663_ASUS_MODE8] = "asus-mode8",
18464         [ALC272_DELL]           = "dell",
18465         [ALC272_DELL_ZM1]       = "dell-zm1",
18466         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18467         [ALC662_AUTO]           = "auto",
18468 };
18469
18470 static const struct snd_pci_quirk alc662_cfg_tbl[] = {
18471         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18472         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18473         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18474         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18475         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18476         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18477         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18478         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18479         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18480         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18481         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18482         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18483         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18484         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18485         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18486         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18487         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18488         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18489         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18490         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18491         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18492         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18493         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18494         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18495         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18496         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18497         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18498         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18499         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18500         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18501         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18502         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18503         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18504         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18505         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18506         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18507         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18508         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18509         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18510         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18511         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18512         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18513         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18514         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18515         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18516         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18517         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18518         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18519         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18520         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18521         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18522         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18523         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18524         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18525         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18526         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18527         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18528         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18529         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18530         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18531         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18532         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18533         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18534         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18535                       ALC662_3ST_6ch_DIG),
18536         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18537         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18538         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18539                       ALC662_3ST_6ch_DIG),
18540         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18541         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18542         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18543         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18544         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18545                                         ALC662_3ST_6ch_DIG),
18546         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18547                            ALC663_ASUS_H13),
18548         SND_PCI_QUIRK(0x1991, 0x5628, "Ordissimo EVE", ALC662_LENOVO_101E),
18549         {}
18550 };
18551
18552 static const struct alc_config_preset alc662_presets[] = {
18553         [ALC662_3ST_2ch_DIG] = {
18554                 .mixers = { alc662_3ST_2ch_mixer },
18555                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18556                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18557                 .dac_nids = alc662_dac_nids,
18558                 .dig_out_nid = ALC662_DIGOUT_NID,
18559                 .dig_in_nid = ALC662_DIGIN_NID,
18560                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18561                 .channel_mode = alc662_3ST_2ch_modes,
18562                 .input_mux = &alc662_capture_source,
18563         },
18564         [ALC662_3ST_6ch_DIG] = {
18565                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18566                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18567                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18568                 .dac_nids = alc662_dac_nids,
18569                 .dig_out_nid = ALC662_DIGOUT_NID,
18570                 .dig_in_nid = ALC662_DIGIN_NID,
18571                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18572                 .channel_mode = alc662_3ST_6ch_modes,
18573                 .need_dac_fix = 1,
18574                 .input_mux = &alc662_capture_source,
18575         },
18576         [ALC662_3ST_6ch] = {
18577                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18578                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18579                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18580                 .dac_nids = alc662_dac_nids,
18581                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18582                 .channel_mode = alc662_3ST_6ch_modes,
18583                 .need_dac_fix = 1,
18584                 .input_mux = &alc662_capture_source,
18585         },
18586         [ALC662_5ST_DIG] = {
18587                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18588                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18589                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18590                 .dac_nids = alc662_dac_nids,
18591                 .dig_out_nid = ALC662_DIGOUT_NID,
18592                 .dig_in_nid = ALC662_DIGIN_NID,
18593                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18594                 .channel_mode = alc662_5stack_modes,
18595                 .input_mux = &alc662_capture_source,
18596         },
18597         [ALC662_LENOVO_101E] = {
18598                 .mixers = { alc662_lenovo_101e_mixer },
18599                 .init_verbs = { alc662_init_verbs,
18600                                 alc662_eapd_init_verbs,
18601                                 alc662_sue_init_verbs },
18602                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18603                 .dac_nids = alc662_dac_nids,
18604                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18605                 .channel_mode = alc662_3ST_2ch_modes,
18606                 .input_mux = &alc662_lenovo_101e_capture_source,
18607                 .unsol_event = alc_sku_unsol_event,
18608                 .setup = alc662_lenovo_101e_setup,
18609                 .init_hook = alc_inithook,
18610         },
18611         [ALC662_ASUS_EEEPC_P701] = {
18612                 .mixers = { alc662_eeepc_p701_mixer },
18613                 .init_verbs = { alc662_init_verbs,
18614                                 alc662_eapd_init_verbs,
18615                                 alc662_eeepc_sue_init_verbs },
18616                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18617                 .dac_nids = alc662_dac_nids,
18618                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18619                 .channel_mode = alc662_3ST_2ch_modes,
18620                 .unsol_event = alc_sku_unsol_event,
18621                 .setup = alc662_eeepc_setup,
18622                 .init_hook = alc_inithook,
18623         },
18624         [ALC662_ASUS_EEEPC_EP20] = {
18625                 .mixers = { alc662_eeepc_ep20_mixer,
18626                             alc662_chmode_mixer },
18627                 .init_verbs = { alc662_init_verbs,
18628                                 alc662_eapd_init_verbs,
18629                                 alc662_eeepc_ep20_sue_init_verbs },
18630                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18631                 .dac_nids = alc662_dac_nids,
18632                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18633                 .channel_mode = alc662_3ST_6ch_modes,
18634                 .input_mux = &alc662_lenovo_101e_capture_source,
18635                 .unsol_event = alc_sku_unsol_event,
18636                 .setup = alc662_eeepc_ep20_setup,
18637                 .init_hook = alc_inithook,
18638         },
18639         [ALC662_ECS] = {
18640                 .mixers = { alc662_ecs_mixer },
18641                 .init_verbs = { alc662_init_verbs,
18642                                 alc662_eapd_init_verbs,
18643                                 alc662_ecs_init_verbs },
18644                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18645                 .dac_nids = alc662_dac_nids,
18646                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18647                 .channel_mode = alc662_3ST_2ch_modes,
18648                 .unsol_event = alc_sku_unsol_event,
18649                 .setup = alc662_eeepc_setup,
18650                 .init_hook = alc_inithook,
18651         },
18652         [ALC663_ASUS_M51VA] = {
18653                 .mixers = { alc663_m51va_mixer },
18654                 .init_verbs = { alc662_init_verbs,
18655                                 alc662_eapd_init_verbs,
18656                                 alc663_m51va_init_verbs },
18657                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18658                 .dac_nids = alc662_dac_nids,
18659                 .dig_out_nid = ALC662_DIGOUT_NID,
18660                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18661                 .channel_mode = alc662_3ST_2ch_modes,
18662                 .unsol_event = alc_sku_unsol_event,
18663                 .setup = alc663_m51va_setup,
18664                 .init_hook = alc_inithook,
18665         },
18666         [ALC663_ASUS_G71V] = {
18667                 .mixers = { alc663_g71v_mixer },
18668                 .init_verbs = { alc662_init_verbs,
18669                                 alc662_eapd_init_verbs,
18670                                 alc663_g71v_init_verbs },
18671                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18672                 .dac_nids = alc662_dac_nids,
18673                 .dig_out_nid = ALC662_DIGOUT_NID,
18674                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18675                 .channel_mode = alc662_3ST_2ch_modes,
18676                 .unsol_event = alc_sku_unsol_event,
18677                 .setup = alc663_g71v_setup,
18678                 .init_hook = alc_inithook,
18679         },
18680         [ALC663_ASUS_H13] = {
18681                 .mixers = { alc663_m51va_mixer },
18682                 .init_verbs = { alc662_init_verbs,
18683                                 alc662_eapd_init_verbs,
18684                                 alc663_m51va_init_verbs },
18685                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18686                 .dac_nids = alc662_dac_nids,
18687                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18688                 .channel_mode = alc662_3ST_2ch_modes,
18689                 .setup = alc663_m51va_setup,
18690                 .unsol_event = alc_sku_unsol_event,
18691                 .init_hook = alc_inithook,
18692         },
18693         [ALC663_ASUS_G50V] = {
18694                 .mixers = { alc663_g50v_mixer },
18695                 .init_verbs = { alc662_init_verbs,
18696                                 alc662_eapd_init_verbs,
18697                                 alc663_g50v_init_verbs },
18698                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18699                 .dac_nids = alc662_dac_nids,
18700                 .dig_out_nid = ALC662_DIGOUT_NID,
18701                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18702                 .channel_mode = alc662_3ST_6ch_modes,
18703                 .input_mux = &alc663_capture_source,
18704                 .unsol_event = alc_sku_unsol_event,
18705                 .setup = alc663_g50v_setup,
18706                 .init_hook = alc_inithook,
18707         },
18708         [ALC663_ASUS_MODE1] = {
18709                 .mixers = { alc663_m51va_mixer },
18710                 .cap_mixer = alc662_auto_capture_mixer,
18711                 .init_verbs = { alc662_init_verbs,
18712                                 alc662_eapd_init_verbs,
18713                                 alc663_21jd_amic_init_verbs },
18714                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18715                 .hp_nid = 0x03,
18716                 .dac_nids = alc662_dac_nids,
18717                 .dig_out_nid = ALC662_DIGOUT_NID,
18718                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18719                 .channel_mode = alc662_3ST_2ch_modes,
18720                 .unsol_event = alc_sku_unsol_event,
18721                 .setup = alc663_mode1_setup,
18722                 .init_hook = alc_inithook,
18723         },
18724         [ALC662_ASUS_MODE2] = {
18725                 .mixers = { alc662_1bjd_mixer },
18726                 .cap_mixer = alc662_auto_capture_mixer,
18727                 .init_verbs = { alc662_init_verbs,
18728                                 alc662_eapd_init_verbs,
18729                                 alc662_1bjd_amic_init_verbs },
18730                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18731                 .dac_nids = alc662_dac_nids,
18732                 .dig_out_nid = ALC662_DIGOUT_NID,
18733                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18734                 .channel_mode = alc662_3ST_2ch_modes,
18735                 .unsol_event = alc_sku_unsol_event,
18736                 .setup = alc662_mode2_setup,
18737                 .init_hook = alc_inithook,
18738         },
18739         [ALC663_ASUS_MODE3] = {
18740                 .mixers = { alc663_two_hp_m1_mixer },
18741                 .cap_mixer = alc662_auto_capture_mixer,
18742                 .init_verbs = { alc662_init_verbs,
18743                                 alc662_eapd_init_verbs,
18744                                 alc663_two_hp_amic_m1_init_verbs },
18745                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18746                 .hp_nid = 0x03,
18747                 .dac_nids = alc662_dac_nids,
18748                 .dig_out_nid = ALC662_DIGOUT_NID,
18749                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18750                 .channel_mode = alc662_3ST_2ch_modes,
18751                 .unsol_event = alc_sku_unsol_event,
18752                 .setup = alc663_mode3_setup,
18753                 .init_hook = alc_inithook,
18754         },
18755         [ALC663_ASUS_MODE4] = {
18756                 .mixers = { alc663_asus_21jd_clfe_mixer },
18757                 .cap_mixer = alc662_auto_capture_mixer,
18758                 .init_verbs = { alc662_init_verbs,
18759                                 alc662_eapd_init_verbs,
18760                                 alc663_21jd_amic_init_verbs},
18761                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18762                 .hp_nid = 0x03,
18763                 .dac_nids = alc662_dac_nids,
18764                 .dig_out_nid = ALC662_DIGOUT_NID,
18765                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18766                 .channel_mode = alc662_3ST_2ch_modes,
18767                 .unsol_event = alc_sku_unsol_event,
18768                 .setup = alc663_mode4_setup,
18769                 .init_hook = alc_inithook,
18770         },
18771         [ALC663_ASUS_MODE5] = {
18772                 .mixers = { alc663_asus_15jd_clfe_mixer },
18773                 .cap_mixer = alc662_auto_capture_mixer,
18774                 .init_verbs = { alc662_init_verbs,
18775                                 alc662_eapd_init_verbs,
18776                                 alc663_15jd_amic_init_verbs },
18777                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18778                 .hp_nid = 0x03,
18779                 .dac_nids = alc662_dac_nids,
18780                 .dig_out_nid = ALC662_DIGOUT_NID,
18781                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18782                 .channel_mode = alc662_3ST_2ch_modes,
18783                 .unsol_event = alc_sku_unsol_event,
18784                 .setup = alc663_mode5_setup,
18785                 .init_hook = alc_inithook,
18786         },
18787         [ALC663_ASUS_MODE6] = {
18788                 .mixers = { alc663_two_hp_m2_mixer },
18789                 .cap_mixer = alc662_auto_capture_mixer,
18790                 .init_verbs = { alc662_init_verbs,
18791                                 alc662_eapd_init_verbs,
18792                                 alc663_two_hp_amic_m2_init_verbs },
18793                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18794                 .hp_nid = 0x03,
18795                 .dac_nids = alc662_dac_nids,
18796                 .dig_out_nid = ALC662_DIGOUT_NID,
18797                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18798                 .channel_mode = alc662_3ST_2ch_modes,
18799                 .unsol_event = alc_sku_unsol_event,
18800                 .setup = alc663_mode6_setup,
18801                 .init_hook = alc_inithook,
18802         },
18803         [ALC663_ASUS_MODE7] = {
18804                 .mixers = { alc663_mode7_mixer },
18805                 .cap_mixer = alc662_auto_capture_mixer,
18806                 .init_verbs = { alc662_init_verbs,
18807                                 alc662_eapd_init_verbs,
18808                                 alc663_mode7_init_verbs },
18809                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18810                 .hp_nid = 0x03,
18811                 .dac_nids = alc662_dac_nids,
18812                 .dig_out_nid = ALC662_DIGOUT_NID,
18813                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18814                 .channel_mode = alc662_3ST_2ch_modes,
18815                 .unsol_event = alc_sku_unsol_event,
18816                 .setup = alc663_mode7_setup,
18817                 .init_hook = alc_inithook,
18818         },
18819         [ALC663_ASUS_MODE8] = {
18820                 .mixers = { alc663_mode8_mixer },
18821                 .cap_mixer = alc662_auto_capture_mixer,
18822                 .init_verbs = { alc662_init_verbs,
18823                                 alc662_eapd_init_verbs,
18824                                 alc663_mode8_init_verbs },
18825                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18826                 .hp_nid = 0x03,
18827                 .dac_nids = alc662_dac_nids,
18828                 .dig_out_nid = ALC662_DIGOUT_NID,
18829                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18830                 .channel_mode = alc662_3ST_2ch_modes,
18831                 .unsol_event = alc_sku_unsol_event,
18832                 .setup = alc663_mode8_setup,
18833                 .init_hook = alc_inithook,
18834         },
18835         [ALC272_DELL] = {
18836                 .mixers = { alc663_m51va_mixer },
18837                 .cap_mixer = alc272_auto_capture_mixer,
18838                 .init_verbs = { alc662_init_verbs,
18839                                 alc662_eapd_init_verbs,
18840                                 alc272_dell_init_verbs },
18841                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18842                 .dac_nids = alc272_dac_nids,
18843                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18844                 .adc_nids = alc272_adc_nids,
18845                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18846                 .capsrc_nids = alc272_capsrc_nids,
18847                 .channel_mode = alc662_3ST_2ch_modes,
18848                 .unsol_event = alc_sku_unsol_event,
18849                 .setup = alc663_m51va_setup,
18850                 .init_hook = alc_inithook,
18851         },
18852         [ALC272_DELL_ZM1] = {
18853                 .mixers = { alc663_m51va_mixer },
18854                 .cap_mixer = alc662_auto_capture_mixer,
18855                 .init_verbs = { alc662_init_verbs,
18856                                 alc662_eapd_init_verbs,
18857                                 alc272_dell_zm1_init_verbs },
18858                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18859                 .dac_nids = alc272_dac_nids,
18860                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18861                 .adc_nids = alc662_adc_nids,
18862                 .num_adc_nids = 1,
18863                 .capsrc_nids = alc662_capsrc_nids,
18864                 .channel_mode = alc662_3ST_2ch_modes,
18865                 .unsol_event = alc_sku_unsol_event,
18866                 .setup = alc663_m51va_setup,
18867                 .init_hook = alc_inithook,
18868         },
18869         [ALC272_SAMSUNG_NC10] = {
18870                 .mixers = { alc272_nc10_mixer },
18871                 .init_verbs = { alc662_init_verbs,
18872                                 alc662_eapd_init_verbs,
18873                                 alc663_21jd_amic_init_verbs },
18874                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18875                 .dac_nids = alc272_dac_nids,
18876                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18877                 .channel_mode = alc662_3ST_2ch_modes,
18878                 /*.input_mux = &alc272_nc10_capture_source,*/
18879                 .unsol_event = alc_sku_unsol_event,
18880                 .setup = alc663_mode4_setup,
18881                 .init_hook = alc_inithook,
18882         },
18883 };
18884
18885
18886 /*
18887  * BIOS auto configuration
18888  */
18889
18890 /* convert from MIX nid to DAC */
18891 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
18892 {
18893         hda_nid_t list[5];
18894         int i, num;
18895
18896         num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
18897         for (i = 0; i < num; i++) {
18898                 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
18899                         return list[i];
18900         }
18901         return 0;
18902 }
18903
18904 /* go down to the selector widget before the mixer */
18905 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
18906 {
18907         hda_nid_t srcs[5];
18908         int num = snd_hda_get_connections(codec, pin, srcs,
18909                                           ARRAY_SIZE(srcs));
18910         if (num != 1 ||
18911             get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
18912                 return pin;
18913         return srcs[0];
18914 }
18915
18916 /* get MIX nid connected to the given pin targeted to DAC */
18917 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18918                                    hda_nid_t dac)
18919 {
18920         hda_nid_t mix[5];
18921         int i, num;
18922
18923         pin = alc_go_down_to_selector(codec, pin);
18924         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18925         for (i = 0; i < num; i++) {
18926                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
18927                         return mix[i];
18928         }
18929         return 0;
18930 }
18931
18932 /* select the connection from pin to DAC if needed */
18933 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
18934                                hda_nid_t dac)
18935 {
18936         hda_nid_t mix[5];
18937         int i, num;
18938
18939         pin = alc_go_down_to_selector(codec, pin);
18940         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18941         if (num < 2)
18942                 return 0;
18943         for (i = 0; i < num; i++) {
18944                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
18945                         snd_hda_codec_update_cache(codec, pin, 0,
18946                                                    AC_VERB_SET_CONNECT_SEL, i);
18947                         return 0;
18948                 }
18949         }
18950         return 0;
18951 }
18952
18953 /* look for an empty DAC slot */
18954 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18955 {
18956         struct alc_spec *spec = codec->spec;
18957         hda_nid_t srcs[5];
18958         int i, j, num;
18959
18960         pin = alc_go_down_to_selector(codec, pin);
18961         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18962         for (i = 0; i < num; i++) {
18963                 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
18964                 if (!nid)
18965                         continue;
18966                 for (j = 0; j < spec->multiout.num_dacs; j++)
18967                         if (spec->multiout.dac_nids[j] == nid)
18968                                 break;
18969                 if (j >= spec->multiout.num_dacs)
18970                         return nid;
18971         }
18972         return 0;
18973 }
18974
18975 /* fill in the dac_nids table from the parsed pin configuration */
18976 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18977                                      const struct auto_pin_cfg *cfg)
18978 {
18979         struct alc_spec *spec = codec->spec;
18980         int i;
18981         hda_nid_t dac;
18982
18983         spec->multiout.dac_nids = spec->private_dac_nids;
18984         spec->multiout.num_dacs = 0;
18985         for (i = 0; i < cfg->line_outs; i++) {
18986                 dac = alc_auto_look_for_dac(codec, cfg->line_out_pins[i]);
18987                 if (!dac)
18988                         continue;
18989                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
18990         }
18991         return 0;
18992 }
18993
18994 static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18995                                        hda_nid_t nid, int idx, unsigned int chs)
18996 {
18997         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx,
18998                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18999 }
19000
19001 static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19002                                       hda_nid_t nid, int idx, unsigned int chs)
19003 {
19004         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
19005                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19006 }
19007
19008 #define alc662_add_vol_ctl(spec, pfx, nid, chs) \
19009         __alc662_add_vol_ctl(spec, pfx, nid, 0, chs)
19010 #define alc662_add_sw_ctl(spec, pfx, nid, chs) \
19011         __alc662_add_sw_ctl(spec, pfx, nid, 0, chs)
19012 #define alc662_add_stereo_vol(spec, pfx, nid) \
19013         alc662_add_vol_ctl(spec, pfx, nid, 3)
19014 #define alc662_add_stereo_sw(spec, pfx, nid) \
19015         alc662_add_sw_ctl(spec, pfx, nid, 3)
19016
19017 /* add playback controls from the parsed DAC table */
19018 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19019                                              const struct auto_pin_cfg *cfg)
19020 {
19021         struct alc_spec *spec = codec->spec;
19022         hda_nid_t nid, mix, pin;
19023         int i, err, noutputs;
19024
19025         noutputs = cfg->line_outs;
19026         if (spec->multi_ios > 0)
19027                 noutputs += spec->multi_ios;
19028
19029         for (i = 0; i < noutputs; i++) {
19030                 const char *name;
19031                 int index;
19032                 nid = spec->multiout.dac_nids[i];
19033                 if (!nid)
19034                         continue;
19035                 if (i >= cfg->line_outs)
19036                         pin = spec->multi_io[i - 1].pin;
19037                 else
19038                         pin = cfg->line_out_pins[i];
19039                 mix = alc_auto_dac_to_mix(codec, pin, nid);
19040                 if (!mix)
19041                         continue;
19042                 name = alc_get_line_out_pfx(spec, i, true, &index);
19043                 if (!name) {
19044                         /* Center/LFE */
19045                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19046                         if (err < 0)
19047                                 return err;
19048                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19049                         if (err < 0)
19050                                 return err;
19051                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19052                         if (err < 0)
19053                                 return err;
19054                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19055                         if (err < 0)
19056                                 return err;
19057                 } else {
19058                         err = __alc662_add_vol_ctl(spec, name, nid, index, 3);
19059                         if (err < 0)
19060                                 return err;
19061                         err = __alc662_add_sw_ctl(spec, name, mix, index, 3);
19062                         if (err < 0)
19063                                 return err;
19064                 }
19065         }
19066         return 0;
19067 }
19068
19069 /* add playback controls for speaker and HP outputs */
19070 /* return DAC nid if any new DAC is assigned */
19071 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19072                                         const char *pfx)
19073 {
19074         struct alc_spec *spec = codec->spec;
19075         hda_nid_t nid, mix;
19076         int err;
19077
19078         if (!pin)
19079                 return 0;
19080         nid = alc_auto_look_for_dac(codec, pin);
19081         if (!nid) {
19082                 /* the corresponding DAC is already occupied */
19083                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19084                         return 0; /* no way */
19085                 /* create a switch only */
19086                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19087                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19088         }
19089
19090         mix = alc_auto_dac_to_mix(codec, pin, nid);
19091         if (!mix)
19092                 return 0;
19093         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19094         if (err < 0)
19095                 return err;
19096         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19097         if (err < 0)
19098                 return err;
19099         return nid;
19100 }
19101
19102 /* create playback/capture controls for input pins */
19103 #define alc662_auto_create_input_ctls \
19104         alc882_auto_create_input_ctls
19105
19106 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19107                                               hda_nid_t nid, int pin_type,
19108                                               hda_nid_t dac)
19109 {
19110         int i, num;
19111         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19112
19113         alc_set_pin_output(codec, nid, pin_type);
19114         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19115         for (i = 0; i < num; i++) {
19116                 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
19117                         continue;
19118                 /* need the manual connection? */
19119                 if (num > 1)
19120                         snd_hda_codec_write(codec, nid, 0,
19121                                             AC_VERB_SET_CONNECT_SEL, i);
19122                 /* unmute mixer widget inputs */
19123                 snd_hda_codec_write(codec, srcs[i], 0,
19124                                     AC_VERB_SET_AMP_GAIN_MUTE,
19125                                     AMP_IN_UNMUTE(0));
19126                 snd_hda_codec_write(codec, srcs[i], 0,
19127                                     AC_VERB_SET_AMP_GAIN_MUTE,
19128                                     AMP_IN_UNMUTE(1));
19129                 return;
19130         }
19131 }
19132
19133 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19134 {
19135         struct alc_spec *spec = codec->spec;
19136         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19137         int i;
19138
19139         for (i = 0; i <= HDA_SIDE; i++) {
19140                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19141                 if (nid)
19142                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19143                                         spec->multiout.dac_nids[i]);
19144         }
19145 }
19146
19147 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19148 {
19149         struct alc_spec *spec = codec->spec;
19150         hda_nid_t pin;
19151
19152         pin = spec->autocfg.hp_pins[0];
19153         if (pin)
19154                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19155                                                   spec->multiout.hp_nid);
19156         pin = spec->autocfg.speaker_pins[0];
19157         if (pin)
19158                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19159                                         spec->multiout.extra_out_nid[0]);
19160 }
19161
19162 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19163
19164 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19165 {
19166         struct alc_spec *spec = codec->spec;
19167         struct auto_pin_cfg *cfg = &spec->autocfg;
19168         int i;
19169
19170         for (i = 0; i < cfg->num_inputs; i++) {
19171                 hda_nid_t nid = cfg->inputs[i].pin;
19172                 if (alc_is_input_pin(codec, nid)) {
19173                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19174                         if (nid != ALC662_PIN_CD_NID &&
19175                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19176                                 snd_hda_codec_write(codec, nid, 0,
19177                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19178                                                     AMP_OUT_MUTE);
19179                 }
19180         }
19181 }
19182
19183 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19184
19185 /*
19186  * multi-io helper
19187  */
19188 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
19189                                    unsigned int location)
19190 {
19191         struct alc_spec *spec = codec->spec;
19192         struct auto_pin_cfg *cfg = &spec->autocfg;
19193         int type, i, num_pins = 0;
19194
19195         for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
19196                 for (i = 0; i < cfg->num_inputs; i++) {
19197                         hda_nid_t nid = cfg->inputs[i].pin;
19198                         hda_nid_t dac;
19199                         unsigned int defcfg, caps;
19200                         if (cfg->inputs[i].type != type)
19201                                 continue;
19202                         defcfg = snd_hda_codec_get_pincfg(codec, nid);
19203                         if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
19204                                 continue;
19205                         if (location && get_defcfg_location(defcfg) != location)
19206                                 continue;
19207                         caps = snd_hda_query_pin_caps(codec, nid);
19208                         if (!(caps & AC_PINCAP_OUT))
19209                                 continue;
19210                         dac = alc_auto_look_for_dac(codec, nid);
19211                         if (!dac)
19212                                 continue;
19213                         spec->multi_io[num_pins].pin = nid;
19214                         spec->multi_io[num_pins].dac = dac;
19215                         num_pins++;
19216                         spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
19217                 }
19218         }
19219         spec->multiout.num_dacs = 1;
19220         if (num_pins < 2)
19221                 return 0;
19222         return num_pins;
19223 }
19224
19225 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
19226                                  struct snd_ctl_elem_info *uinfo)
19227 {
19228         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19229         struct alc_spec *spec = codec->spec;
19230
19231         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
19232         uinfo->count = 1;
19233         uinfo->value.enumerated.items = spec->multi_ios + 1;
19234         if (uinfo->value.enumerated.item > spec->multi_ios)
19235                 uinfo->value.enumerated.item = spec->multi_ios;
19236         sprintf(uinfo->value.enumerated.name, "%dch",
19237                 (uinfo->value.enumerated.item + 1) * 2);
19238         return 0;
19239 }
19240
19241 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
19242                                 struct snd_ctl_elem_value *ucontrol)
19243 {
19244         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19245         struct alc_spec *spec = codec->spec;
19246         ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
19247         return 0;
19248 }
19249
19250 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
19251 {
19252         struct alc_spec *spec = codec->spec;
19253         hda_nid_t nid = spec->multi_io[idx].pin;
19254
19255         if (!spec->multi_io[idx].ctl_in)
19256                 spec->multi_io[idx].ctl_in =
19257                         snd_hda_codec_read(codec, nid, 0,
19258                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
19259         if (output) {
19260                 snd_hda_codec_update_cache(codec, nid, 0,
19261                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
19262                                            PIN_OUT);
19263                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
19264                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
19265                                                  HDA_AMP_MUTE, 0);
19266                 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
19267         } else {
19268                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
19269                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
19270                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
19271                 snd_hda_codec_update_cache(codec, nid, 0,
19272                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
19273                                            spec->multi_io[idx].ctl_in);
19274         }
19275         return 0;
19276 }
19277
19278 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
19279                                 struct snd_ctl_elem_value *ucontrol)
19280 {
19281         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19282         struct alc_spec *spec = codec->spec;
19283         int i, ch;
19284
19285         ch = ucontrol->value.enumerated.item[0];
19286         if (ch < 0 || ch > spec->multi_ios)
19287                 return -EINVAL;
19288         if (ch == (spec->ext_channel_count - 1) / 2)
19289                 return 0;
19290         spec->ext_channel_count = (ch + 1) * 2;
19291         for (i = 0; i < spec->multi_ios; i++)
19292                 alc_set_multi_io(codec, i, i < ch);
19293         spec->multiout.max_channels = spec->ext_channel_count;
19294         return 1;
19295 }
19296
19297 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
19298         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
19299         .name = "Channel Mode",
19300         .info = alc_auto_ch_mode_info,
19301         .get = alc_auto_ch_mode_get,
19302         .put = alc_auto_ch_mode_put,
19303 };
19304
19305 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
19306 {
19307         struct alc_spec *spec = codec->spec;
19308         struct auto_pin_cfg *cfg = &spec->autocfg;
19309         unsigned int location, defcfg;
19310         int num_pins;
19311
19312         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && cfg->hp_outs == 1) {
19313                 /* use HP as primary out */
19314                 cfg->speaker_outs = cfg->line_outs;
19315                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
19316                        sizeof(cfg->speaker_pins));
19317                 cfg->line_outs = cfg->hp_outs;
19318                 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
19319                 cfg->hp_outs = 0;
19320                 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
19321                 cfg->line_out_type = AUTO_PIN_HP_OUT;
19322                 alc662_auto_fill_dac_nids(codec, cfg);
19323         }
19324         if (cfg->line_outs != 1 ||
19325             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19326                 return 0;
19327
19328         defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
19329         location = get_defcfg_location(defcfg);
19330
19331         num_pins = alc_auto_fill_multi_ios(codec, location);
19332         if (num_pins > 0) {
19333                 struct snd_kcontrol_new *knew;
19334
19335                 knew = alc_kcontrol_new(spec);
19336                 if (!knew)
19337                         return -ENOMEM;
19338                 *knew = alc_auto_channel_mode_enum;
19339                 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
19340                 if (!knew->name)
19341                         return -ENOMEM;
19342
19343                 spec->multi_ios = num_pins;
19344                 spec->ext_channel_count = 2;
19345                 spec->multiout.num_dacs = num_pins + 1;
19346         }
19347         return 0;
19348 }
19349
19350 static int alc662_parse_auto_config(struct hda_codec *codec)
19351 {
19352         struct alc_spec *spec = codec->spec;
19353         int err;
19354         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19355
19356         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19357                                            alc662_ignore);
19358         if (err < 0)
19359                 return err;
19360         if (!spec->autocfg.line_outs)
19361                 return 0; /* can't find valid BIOS pin config */
19362
19363         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19364         if (err < 0)
19365                 return err;
19366         err = alc_auto_add_multi_channel_mode(codec);
19367         if (err < 0)
19368                 return err;
19369         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19370         if (err < 0)
19371                 return err;
19372         err = alc662_auto_create_extra_out(codec,
19373                                            spec->autocfg.speaker_pins[0],
19374                                            "Speaker");
19375         if (err < 0)
19376                 return err;
19377         if (err)
19378                 spec->multiout.extra_out_nid[0] = err;
19379         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19380                                            "Headphone");
19381         if (err < 0)
19382                 return err;
19383         if (err)
19384                 spec->multiout.hp_nid = err;
19385         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19386         if (err < 0)
19387                 return err;
19388
19389         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19390
19391         alc_auto_parse_digital(codec);
19392
19393         if (spec->kctls.list)
19394                 add_mixer(spec, spec->kctls.list);
19395
19396         spec->num_mux_defs = 1;
19397         spec->input_mux = &spec->private_imux[0];
19398
19399         err = alc_auto_add_mic_boost(codec);
19400         if (err < 0)
19401                 return err;
19402
19403         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19404             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19405             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19406         else
19407             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19408
19409         return 1;
19410 }
19411
19412 /* additional initialization for auto-configuration model */
19413 static void alc662_auto_init(struct hda_codec *codec)
19414 {
19415         struct alc_spec *spec = codec->spec;
19416         alc662_auto_init_multi_out(codec);
19417         alc662_auto_init_hp_out(codec);
19418         alc662_auto_init_analog_input(codec);
19419         alc662_auto_init_input_src(codec);
19420         alc_auto_init_digital(codec);
19421         if (spec->unsol_event)
19422                 alc_inithook(codec);
19423 }
19424
19425 static void alc272_fixup_mario(struct hda_codec *codec,
19426                                const struct alc_fixup *fix, int action)
19427 {
19428         if (action != ALC_FIXUP_ACT_PROBE)
19429                 return;
19430         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19431                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19432                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19433                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19434                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
19435                 printk(KERN_WARNING
19436                        "hda_codec: failed to override amp caps for NID 0x2\n");
19437 }
19438
19439 enum {
19440         ALC662_FIXUP_ASPIRE,
19441         ALC662_FIXUP_IDEAPAD,
19442         ALC272_FIXUP_MARIO,
19443         ALC662_FIXUP_CZC_P10T,
19444         ALC662_FIXUP_SKU_IGNORE,
19445 };
19446
19447 static const struct alc_fixup alc662_fixups[] = {
19448         [ALC662_FIXUP_ASPIRE] = {
19449                 .type = ALC_FIXUP_PINS,
19450                 .v.pins = (const struct alc_pincfg[]) {
19451                         { 0x15, 0x99130112 }, /* subwoofer */
19452                         { }
19453                 }
19454         },
19455         [ALC662_FIXUP_IDEAPAD] = {
19456                 .type = ALC_FIXUP_PINS,
19457                 .v.pins = (const struct alc_pincfg[]) {
19458                         { 0x17, 0x99130112 }, /* subwoofer */
19459                         { }
19460                 }
19461         },
19462         [ALC272_FIXUP_MARIO] = {
19463                 .type = ALC_FIXUP_FUNC,
19464                 .v.func = alc272_fixup_mario,
19465         },
19466         [ALC662_FIXUP_CZC_P10T] = {
19467                 .type = ALC_FIXUP_VERBS,
19468                 .v.verbs = (const struct hda_verb[]) {
19469                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
19470                         {}
19471                 }
19472         },
19473         [ALC662_FIXUP_SKU_IGNORE] = {
19474                 .type = ALC_FIXUP_SKU,
19475                 .v.sku = ALC_FIXUP_SKU_IGNORE,
19476         },
19477 };
19478
19479 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
19480         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
19481         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
19482         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19483         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19484         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19485         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19486         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
19487         {}
19488 };
19489
19490 static const struct alc_model_fixup alc662_fixup_models[] = {
19491         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19492         {}
19493 };
19494
19495
19496 static int patch_alc662(struct hda_codec *codec)
19497 {
19498         struct alc_spec *spec;
19499         int err, board_config;
19500         int coef;
19501
19502         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19503         if (!spec)
19504                 return -ENOMEM;
19505
19506         codec->spec = spec;
19507
19508         alc_auto_parse_customize_define(codec);
19509
19510         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19511
19512         coef = alc_read_coef_idx(codec, 0);
19513         if (coef == 0x8020 || coef == 0x8011)
19514                 alc_codec_rename(codec, "ALC661");
19515         else if (coef & (1 << 14) &&
19516                 codec->bus->pci->subsystem_vendor == 0x1025 &&
19517                 spec->cdefine.platform_type == 1)
19518                 alc_codec_rename(codec, "ALC272X");
19519         else if (coef == 0x4011)
19520                 alc_codec_rename(codec, "ALC656");
19521
19522         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19523                                                   alc662_models,
19524                                                   alc662_cfg_tbl);
19525         if (board_config < 0) {
19526                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19527                        codec->chip_name);
19528                 board_config = ALC662_AUTO;
19529         }
19530
19531         if (board_config == ALC662_AUTO) {
19532                 alc_pick_fixup(codec, alc662_fixup_models,
19533                                alc662_fixup_tbl, alc662_fixups);
19534                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
19535                 /* automatic parse from the BIOS config */
19536                 err = alc662_parse_auto_config(codec);
19537                 if (err < 0) {
19538                         alc_free(codec);
19539                         return err;
19540                 } else if (!err) {
19541                         printk(KERN_INFO
19542                                "hda_codec: Cannot set up configuration "
19543                                "from BIOS.  Using base mode...\n");
19544                         board_config = ALC662_3ST_2ch_DIG;
19545                 }
19546         }
19547
19548         if (has_cdefine_beep(codec)) {
19549                 err = snd_hda_attach_beep_device(codec, 0x1);
19550                 if (err < 0) {
19551                         alc_free(codec);
19552                         return err;
19553                 }
19554         }
19555
19556         if (board_config != ALC662_AUTO)
19557                 setup_preset(codec, &alc662_presets[board_config]);
19558
19559         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19560         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19561
19562         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19563         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19564
19565         if (!spec->adc_nids) {
19566                 spec->adc_nids = alc662_adc_nids;
19567                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19568         }
19569         if (!spec->capsrc_nids)
19570                 spec->capsrc_nids = alc662_capsrc_nids;
19571
19572         if (!spec->cap_mixer)
19573                 set_capture_mixer(codec);
19574
19575         if (has_cdefine_beep(codec)) {
19576                 switch (codec->vendor_id) {
19577                 case 0x10ec0662:
19578                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19579                         break;
19580                 case 0x10ec0272:
19581                 case 0x10ec0663:
19582                 case 0x10ec0665:
19583                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19584                         break;
19585                 case 0x10ec0273:
19586                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19587                         break;
19588                 }
19589         }
19590         spec->vmaster_nid = 0x02;
19591
19592         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
19593
19594         codec->patch_ops = alc_patch_ops;
19595         if (board_config == ALC662_AUTO)
19596                 spec->init_hook = alc662_auto_init;
19597         spec->shutup = alc_eapd_shutup;
19598
19599         alc_init_jacks(codec);
19600
19601 #ifdef CONFIG_SND_HDA_POWER_SAVE
19602         if (!spec->loopback.amplist)
19603                 spec->loopback.amplist = alc662_loopbacks;
19604 #endif
19605
19606         return 0;
19607 }
19608
19609 static int patch_alc888(struct hda_codec *codec)
19610 {
19611         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19612                 kfree(codec->chip_name);
19613                 if (codec->vendor_id == 0x10ec0887)
19614                         codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19615                 else
19616                         codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19617                 if (!codec->chip_name) {
19618                         alc_free(codec);
19619                         return -ENOMEM;
19620                 }
19621                 return patch_alc662(codec);
19622         }
19623         return patch_alc882(codec);
19624 }
19625
19626 static int patch_alc899(struct hda_codec *codec)
19627 {
19628         if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) {
19629                 kfree(codec->chip_name);
19630                 codec->chip_name = kstrdup("ALC898", GFP_KERNEL);
19631         }
19632         return patch_alc882(codec);
19633 }
19634
19635 /*
19636  * ALC680 support
19637  */
19638 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19639 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19640 #define alc680_modes            alc260_modes
19641
19642 static const hda_nid_t alc680_dac_nids[3] = {
19643         /* Lout1, Lout2, hp */
19644         0x02, 0x03, 0x04
19645 };
19646
19647 static const hda_nid_t alc680_adc_nids[3] = {
19648         /* ADC0-2 */
19649         /* DMIC, MIC, Line-in*/
19650         0x07, 0x08, 0x09
19651 };
19652
19653 /*
19654  * Analog capture ADC cgange
19655  */
19656 static void alc680_rec_autoswitch(struct hda_codec *codec)
19657 {
19658         struct alc_spec *spec = codec->spec;
19659         struct auto_pin_cfg *cfg = &spec->autocfg;
19660         int pin_found = 0;
19661         int type_found = AUTO_PIN_LAST;
19662         hda_nid_t nid;
19663         int i;
19664
19665         for (i = 0; i < cfg->num_inputs; i++) {
19666                 nid = cfg->inputs[i].pin;
19667                 if (!is_jack_detectable(codec, nid))
19668                         continue;
19669                 if (snd_hda_jack_detect(codec, nid)) {
19670                         if (cfg->inputs[i].type < type_found) {
19671                                 type_found = cfg->inputs[i].type;
19672                                 pin_found = nid;
19673                         }
19674                 }
19675         }
19676
19677         nid = 0x07;
19678         if (pin_found)
19679                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19680
19681         if (nid != spec->cur_adc)
19682                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19683         spec->cur_adc = nid;
19684         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19685                                    spec->cur_adc_format);
19686 }
19687
19688 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19689                                       struct hda_codec *codec,
19690                                       unsigned int stream_tag,
19691                                       unsigned int format,
19692                                       struct snd_pcm_substream *substream)
19693 {
19694         struct alc_spec *spec = codec->spec;
19695
19696         spec->cur_adc = 0x07;
19697         spec->cur_adc_stream_tag = stream_tag;
19698         spec->cur_adc_format = format;
19699
19700         alc680_rec_autoswitch(codec);
19701         return 0;
19702 }
19703
19704 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19705                                       struct hda_codec *codec,
19706                                       struct snd_pcm_substream *substream)
19707 {
19708         snd_hda_codec_cleanup_stream(codec, 0x07);
19709         snd_hda_codec_cleanup_stream(codec, 0x08);
19710         snd_hda_codec_cleanup_stream(codec, 0x09);
19711         return 0;
19712 }
19713
19714 static const struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19715         .substreams = 1, /* can be overridden */
19716         .channels_min = 2,
19717         .channels_max = 2,
19718         /* NID is set in alc_build_pcms */
19719         .ops = {
19720                 .prepare = alc680_capture_pcm_prepare,
19721                 .cleanup = alc680_capture_pcm_cleanup
19722         },
19723 };
19724
19725 static const struct snd_kcontrol_new alc680_base_mixer[] = {
19726         /* output mixer control */
19727         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19728         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19729         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19730         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19731         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
19732         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
19733         HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
19734         { }
19735 };
19736
19737 static const struct hda_bind_ctls alc680_bind_cap_vol = {
19738         .ops = &snd_hda_bind_vol,
19739         .values = {
19740                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19741                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19742                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19743                 0
19744         },
19745 };
19746
19747 static const struct hda_bind_ctls alc680_bind_cap_switch = {
19748         .ops = &snd_hda_bind_sw,
19749         .values = {
19750                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19751                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19752                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19753                 0
19754         },
19755 };
19756
19757 static const struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19758         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19759         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19760         { } /* end */
19761 };
19762
19763 /*
19764  * generic initialization of ADC, input mixers and output mixers
19765  */
19766 static const struct hda_verb alc680_init_verbs[] = {
19767         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19768         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19769         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19770
19771         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19772         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19773         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19774         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19775         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19776         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19777
19778         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19779         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19780         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19781         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19782         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19783
19784         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19785         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19786         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19787
19788         { }
19789 };
19790
19791 /* toggle speaker-output according to the hp-jack state */
19792 static void alc680_base_setup(struct hda_codec *codec)
19793 {
19794         struct alc_spec *spec = codec->spec;
19795
19796         spec->autocfg.hp_pins[0] = 0x16;
19797         spec->autocfg.speaker_pins[0] = 0x14;
19798         spec->autocfg.speaker_pins[1] = 0x15;
19799         spec->autocfg.num_inputs = 2;
19800         spec->autocfg.inputs[0].pin = 0x18;
19801         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19802         spec->autocfg.inputs[1].pin = 0x19;
19803         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19804         spec->automute = 1;
19805         spec->automute_mode = ALC_AUTOMUTE_AMP;
19806 }
19807
19808 static void alc680_unsol_event(struct hda_codec *codec,
19809                                            unsigned int res)
19810 {
19811         if ((res >> 26) == ALC880_HP_EVENT)
19812                 alc_hp_automute(codec);
19813         if ((res >> 26) == ALC880_MIC_EVENT)
19814                 alc680_rec_autoswitch(codec);
19815 }
19816
19817 static void alc680_inithook(struct hda_codec *codec)
19818 {
19819         alc_hp_automute(codec);
19820         alc680_rec_autoswitch(codec);
19821 }
19822
19823 /* create input playback/capture controls for the given pin */
19824 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19825                                     const char *ctlname, int idx)
19826 {
19827         hda_nid_t dac;
19828         int err;
19829
19830         switch (nid) {
19831         case 0x14:
19832                 dac = 0x02;
19833                 break;
19834         case 0x15:
19835                 dac = 0x03;
19836                 break;
19837         case 0x16:
19838                 dac = 0x04;
19839                 break;
19840         default:
19841                 return 0;
19842         }
19843         if (spec->multiout.dac_nids[0] != dac &&
19844             spec->multiout.dac_nids[1] != dac) {
19845                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19846                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19847                                                       HDA_OUTPUT));
19848                 if (err < 0)
19849                         return err;
19850
19851                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19852                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19853
19854                 if (err < 0)
19855                         return err;
19856                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
19857         }
19858
19859         return 0;
19860 }
19861
19862 /* add playback controls from the parsed DAC table */
19863 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19864                                              const struct auto_pin_cfg *cfg)
19865 {
19866         hda_nid_t nid;
19867         int err;
19868
19869         spec->multiout.dac_nids = spec->private_dac_nids;
19870
19871         nid = cfg->line_out_pins[0];
19872         if (nid) {
19873                 const char *name;
19874                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19875                         name = "Speaker";
19876                 else
19877                         name = "Front";
19878                 err = alc680_new_analog_output(spec, nid, name, 0);
19879                 if (err < 0)
19880                         return err;
19881         }
19882
19883         nid = cfg->speaker_pins[0];
19884         if (nid) {
19885                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19886                 if (err < 0)
19887                         return err;
19888         }
19889         nid = cfg->hp_pins[0];
19890         if (nid) {
19891                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19892                 if (err < 0)
19893                         return err;
19894         }
19895
19896         return 0;
19897 }
19898
19899 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19900                                               hda_nid_t nid, int pin_type)
19901 {
19902         alc_set_pin_output(codec, nid, pin_type);
19903 }
19904
19905 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19906 {
19907         struct alc_spec *spec = codec->spec;
19908         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19909         if (nid) {
19910                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19911                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19912         }
19913 }
19914
19915 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19916 {
19917         struct alc_spec *spec = codec->spec;
19918         hda_nid_t pin;
19919
19920         pin = spec->autocfg.hp_pins[0];
19921         if (pin)
19922                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19923         pin = spec->autocfg.speaker_pins[0];
19924         if (pin)
19925                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19926 }
19927
19928 /* pcm configuration: identical with ALC880 */
19929 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19930 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19931 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19932 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19933 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19934
19935 /*
19936  * BIOS auto configuration
19937  */
19938 static int alc680_parse_auto_config(struct hda_codec *codec)
19939 {
19940         struct alc_spec *spec = codec->spec;
19941         int err;
19942         static const hda_nid_t alc680_ignore[] = { 0 };
19943
19944         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19945                                            alc680_ignore);
19946         if (err < 0)
19947                 return err;
19948
19949         if (!spec->autocfg.line_outs) {
19950                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19951                         spec->multiout.max_channels = 2;
19952                         spec->no_analog = 1;
19953                         goto dig_only;
19954                 }
19955                 return 0; /* can't find valid BIOS pin config */
19956         }
19957         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19958         if (err < 0)
19959                 return err;
19960
19961         spec->multiout.max_channels = 2;
19962
19963  dig_only:
19964         /* digital only support output */
19965         alc_auto_parse_digital(codec);
19966         if (spec->kctls.list)
19967                 add_mixer(spec, spec->kctls.list);
19968
19969         add_verb(spec, alc680_init_verbs);
19970
19971         err = alc_auto_add_mic_boost(codec);
19972         if (err < 0)
19973                 return err;
19974
19975         return 1;
19976 }
19977
19978 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19979
19980 /* init callback for auto-configuration model -- overriding the default init */
19981 static void alc680_auto_init(struct hda_codec *codec)
19982 {
19983         struct alc_spec *spec = codec->spec;
19984         alc680_auto_init_multi_out(codec);
19985         alc680_auto_init_hp_out(codec);
19986         alc680_auto_init_analog_input(codec);
19987         alc_auto_init_digital(codec);
19988         if (spec->unsol_event)
19989                 alc_inithook(codec);
19990 }
19991
19992 /*
19993  * configuration and preset
19994  */
19995 static const char * const alc680_models[ALC680_MODEL_LAST] = {
19996         [ALC680_BASE]           = "base",
19997         [ALC680_AUTO]           = "auto",
19998 };
19999
20000 static const struct snd_pci_quirk alc680_cfg_tbl[] = {
20001         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
20002         {}
20003 };
20004
20005 static const struct alc_config_preset alc680_presets[] = {
20006         [ALC680_BASE] = {
20007                 .mixers = { alc680_base_mixer },
20008                 .cap_mixer =  alc680_master_capture_mixer,
20009                 .init_verbs = { alc680_init_verbs },
20010                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
20011                 .dac_nids = alc680_dac_nids,
20012                 .dig_out_nid = ALC680_DIGOUT_NID,
20013                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
20014                 .channel_mode = alc680_modes,
20015                 .unsol_event = alc680_unsol_event,
20016                 .setup = alc680_base_setup,
20017                 .init_hook = alc680_inithook,
20018
20019         },
20020 };
20021
20022 static int patch_alc680(struct hda_codec *codec)
20023 {
20024         struct alc_spec *spec;
20025         int board_config;
20026         int err;
20027
20028         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
20029         if (spec == NULL)
20030                 return -ENOMEM;
20031
20032         codec->spec = spec;
20033
20034         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
20035                                                   alc680_models,
20036                                                   alc680_cfg_tbl);
20037
20038         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
20039                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
20040                        codec->chip_name);
20041                 board_config = ALC680_AUTO;
20042         }
20043
20044         if (board_config == ALC680_AUTO) {
20045                 /* automatic parse from the BIOS config */
20046                 err = alc680_parse_auto_config(codec);
20047                 if (err < 0) {
20048                         alc_free(codec);
20049                         return err;
20050                 } else if (!err) {
20051                         printk(KERN_INFO
20052                                "hda_codec: Cannot set up configuration "
20053                                "from BIOS.  Using base mode...\n");
20054                         board_config = ALC680_BASE;
20055                 }
20056         }
20057
20058         if (board_config != ALC680_AUTO)
20059                 setup_preset(codec, &alc680_presets[board_config]);
20060
20061         spec->stream_analog_playback = &alc680_pcm_analog_playback;
20062         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
20063         spec->stream_digital_playback = &alc680_pcm_digital_playback;
20064         spec->stream_digital_capture = &alc680_pcm_digital_capture;
20065
20066         if (!spec->adc_nids) {
20067                 spec->adc_nids = alc680_adc_nids;
20068                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
20069         }
20070
20071         if (!spec->cap_mixer)
20072                 set_capture_mixer(codec);
20073
20074         spec->vmaster_nid = 0x02;
20075
20076         codec->patch_ops = alc_patch_ops;
20077         if (board_config == ALC680_AUTO)
20078                 spec->init_hook = alc680_auto_init;
20079
20080         return 0;
20081 }
20082
20083 /*
20084  * patch entries
20085  */
20086 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
20087         { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
20088         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
20089         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
20090         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
20091         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
20092         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
20093         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
20094         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
20095         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
20096         { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
20097         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
20098           .patch = patch_alc861 },
20099         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
20100         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
20101         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
20102         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
20103           .patch = patch_alc882 },
20104         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
20105           .patch = patch_alc662 },
20106         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
20107         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
20108         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
20109         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
20110         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
20111         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
20112         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
20113         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
20114           .patch = patch_alc882 },
20115         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
20116           .patch = patch_alc882 },
20117         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
20118         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
20119         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
20120           .patch = patch_alc882 },
20121         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20122         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20123         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20124         { .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 },
20125         {} /* terminator */
20126 };
20127
20128 MODULE_ALIAS("snd-hda-codec-id:10ec*");
20129
20130 MODULE_LICENSE("GPL");
20131 MODULE_DESCRIPTION("Realtek HD-audio codec");
20132
20133 static struct hda_codec_preset_list realtek_list = {
20134         .preset = snd_hda_preset_realtek,
20135         .owner = THIS_MODULE,
20136 };
20137
20138 static int __init patch_realtek_init(void)
20139 {
20140         return snd_hda_add_codec_preset(&realtek_list);
20141 }
20142
20143 static void __exit patch_realtek_exit(void)
20144 {
20145         snd_hda_delete_codec_preset(&realtek_list);
20146 }
20147
20148 module_init(patch_realtek_init)
20149 module_exit(patch_realtek_exit)