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 struct alc_jack {
 286         hda_nid_t nid;
 287         int type;
 288         struct snd_jack *jack;
 289 };
 290
 291 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 292
 293 struct alc_customize_define {
 294         unsigned int  sku_cfg;
 295         unsigned char port_connectivity;
 296         unsigned char check_sum;
 297         unsigned char customization;
 298         unsigned char external_amp;
 299         unsigned int  enable_pcbeep:1;
 300         unsigned int  platform_type:1;
 301         unsigned int  swap:1;
 302         unsigned int  override:1;
 303         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
 304 };
 305
 306 struct alc_fixup;
 307
 308 struct alc_spec {
 309         /* codec parameterization */
 310         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 311         unsigned int num_mixers;
 312         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 313         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 314
 315         const struct hda_verb *init_verbs[10];  /* initialization verbs
 316                                                  * don't forget NULL
 317                                                  * termination!
 318                                                  */
 319         unsigned int num_init_verbs;
 320
 321         char stream_name_analog[32];    /* analog PCM stream */
 322         struct hda_pcm_stream *stream_analog_playback;
 323         struct hda_pcm_stream *stream_analog_capture;
 324         struct hda_pcm_stream *stream_analog_alt_playback;
 325         struct hda_pcm_stream *stream_analog_alt_capture;
 326
 327         char stream_name_digital[32];   /* digital PCM stream */
 328         struct hda_pcm_stream *stream_digital_playback;
 329         struct hda_pcm_stream *stream_digital_capture;
 330
 331         /* playback */
 332         struct hda_multi_out multiout;  /* playback set-up
 333                                          * max_channels, dacs must be set
 334                                          * dig_out_nid and hp_nid are optional
 335                                          */
 336         hda_nid_t alt_dac_nid;
 337         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 338         int dig_out_type;
 339
 340         /* capture */
 341         unsigned int num_adc_nids;
 342         hda_nid_t *adc_nids;
 343         hda_nid_t *capsrc_nids;
 344         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 345
 346         /* capture setup for dynamic dual-adc switch */
 347         unsigned int cur_adc_idx;
 348         hda_nid_t cur_adc;
 349         unsigned int cur_adc_stream_tag;
 350         unsigned int cur_adc_format;
 351
 352         /* capture source */
 353         unsigned int num_mux_defs;
 354         const struct hda_input_mux *input_mux;
 355         unsigned int cur_mux[3];
 356         struct alc_mic_route ext_mic;
 357         struct alc_mic_route int_mic;
 358
 359         /* channel model */
 360         const struct hda_channel_mode *channel_mode;
 361         int num_channel_mode;
 362         int need_dac_fix;
 363         int const_channel_count;
 364         int ext_channel_count;
 365
 366         /* PCM information */
 367         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 368
 369         /* jack detection */
 370         struct snd_array jacks;
 371
 372         /* dynamic controls, init_verbs and input_mux */
 373         struct auto_pin_cfg autocfg;
 374         struct alc_customize_define cdefine;
 375         struct snd_array kctls;
 376         struct hda_input_mux private_imux[3];
 377         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 378         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 379         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 380
 381         /* hooks */
 382         void (*init_hook)(struct hda_codec *codec);
 383         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 384 #ifdef CONFIG_SND_HDA_POWER_SAVE
 385         void (*power_hook)(struct hda_codec *codec);
 386 #endif
 387
 388         /* for pin sensing */
 389         unsigned int sense_updated: 1;
 390         unsigned int jack_present: 1;
 391         unsigned int master_sw: 1;
 392         unsigned int auto_mic:1;
 393
 394         /* other flags */
 395         unsigned int no_analog :1; /* digital I/O only */
 396         unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
 397         int init_amp;
 398         int codec_variant;      /* flag for other variants */
 399
 400         /* for virtual master */
 401         hda_nid_t vmaster_nid;
 402 #ifdef CONFIG_SND_HDA_POWER_SAVE
 403         struct hda_loopback_check loopback;
 404 #endif
 405
 406         /* for PLL fix */
 407         hda_nid_t pll_nid;
 408         unsigned int pll_coef_idx, pll_coef_bit;
 409
 410         /* fix-up list */
 411         int fixup_id;
 412         const struct alc_fixup *fixup_list;
 413         const char *fixup_name;
 414 };
 415
 416 /*
 417  * configuration template - to be copied to the spec instance
 418  */
 419 struct alc_config_preset {
 420         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 421                                              * with spec
 422                                              */
 423         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 424         const struct hda_verb *init_verbs[5];
 425         unsigned int num_dacs;
 426         hda_nid_t *dac_nids;
 427         hda_nid_t dig_out_nid;          /* optional */
 428         hda_nid_t hp_nid;               /* optional */
 429         hda_nid_t *slave_dig_outs;
 430         unsigned int num_adc_nids;
 431         hda_nid_t *adc_nids;
 432         hda_nid_t *capsrc_nids;
 433         hda_nid_t dig_in_nid;
 434         unsigned int num_channel_mode;
 435         const struct hda_channel_mode *channel_mode;
 436         int need_dac_fix;
 437         int const_channel_count;
 438         unsigned int num_mux_defs;
 439         const struct hda_input_mux *input_mux;
 440         void (*unsol_event)(struct hda_codec *, unsigned int);
 441         void (*setup)(struct hda_codec *);
 442         void (*init_hook)(struct hda_codec *);
 443 #ifdef CONFIG_SND_HDA_POWER_SAVE
 444         struct hda_amp_list *loopbacks;
 445         void (*power_hook)(struct hda_codec *codec);
 446 #endif
 447 };
 448
 449
 450 /*
 451  * input MUX handling
 452  */
 453 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 454                              struct snd_ctl_elem_info *uinfo)
 455 {
 456         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 457         struct alc_spec *spec = codec->spec;
 458         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 459         if (mux_idx >= spec->num_mux_defs)
 460                 mux_idx = 0;
 461         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 462                 mux_idx = 0;
 463         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 464 }
 465
 466 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 467                             struct snd_ctl_elem_value *ucontrol)
 468 {
 469         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 470         struct alc_spec *spec = codec->spec;
 471         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 472
 473         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 474         return 0;
 475 }
 476
 477 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 478                             struct snd_ctl_elem_value *ucontrol)
 479 {
 480         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 481         struct alc_spec *spec = codec->spec;
 482         const struct hda_input_mux *imux;
 483         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 484         unsigned int mux_idx;
 485         hda_nid_t nid = spec->capsrc_nids ?
 486                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 487         unsigned int type;
 488
 489         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 490         imux = &spec->input_mux[mux_idx];
 491         if (!imux->num_items && mux_idx > 0)
 492                 imux = &spec->input_mux[0];
 493
 494         type = get_wcaps_type(get_wcaps(codec, nid));
 495         if (type == AC_WID_AUD_MIX) {
 496                 /* Matrix-mixer style (e.g. ALC882) */
 497                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 498                 unsigned int i, idx;
 499
 500                 idx = ucontrol->value.enumerated.item[0];
 501                 if (idx >= imux->num_items)
 502                         idx = imux->num_items - 1;
 503                 if (*cur_val == idx)
 504                         return 0;
 505                 for (i = 0; i < imux->num_items; i++) {
 506                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 507                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 508                                                  imux->items[i].index,
 509                                                  HDA_AMP_MUTE, v);
 510                 }
 511                 *cur_val = idx;
 512                 return 1;
 513         } else {
 514                 /* MUX style (e.g. ALC880) */
 515                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 516                                              &spec->cur_mux[adc_idx]);
 517         }
 518 }
 519
 520 /*
 521  * channel mode setting
 522  */
 523 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 524                             struct snd_ctl_elem_info *uinfo)
 525 {
 526         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 527         struct alc_spec *spec = codec->spec;
 528         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 529                                     spec->num_channel_mode);
 530 }
 531
 532 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 533                            struct snd_ctl_elem_value *ucontrol)
 534 {
 535         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 536         struct alc_spec *spec = codec->spec;
 537         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 538                                    spec->num_channel_mode,
 539                                    spec->ext_channel_count);
 540 }
 541
 542 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 543                            struct snd_ctl_elem_value *ucontrol)
 544 {
 545         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 546         struct alc_spec *spec = codec->spec;
 547         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 548                                       spec->num_channel_mode,
 549                                       &spec->ext_channel_count);
 550         if (err >= 0 && !spec->const_channel_count) {
 551                 spec->multiout.max_channels = spec->ext_channel_count;
 552                 if (spec->need_dac_fix)
 553                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 554         }
 555         return err;
 556 }
 557
 558 /*
 559  * Control the mode of pin widget settings via the mixer.  "pc" is used
 560  * instead of "%" to avoid consequences of accidently treating the % as
 561  * being part of a format specifier.  Maximum allowed length of a value is
 562  * 63 characters plus NULL terminator.
 563  *
 564  * Note: some retasking pin complexes seem to ignore requests for input
 565  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 566  * are requested.  Therefore order this list so that this behaviour will not
 567  * cause problems when mixer clients move through the enum sequentially.
 568  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 569  * March 2006.
 570  */
 571 static char *alc_pin_mode_names[] = {
 572         "Mic 50pc bias", "Mic 80pc bias",
 573         "Line in", "Line out", "Headphone out",
 574 };
 575 static unsigned char alc_pin_mode_values[] = {
 576         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 577 };
 578 /* The control can present all 5 options, or it can limit the options based
 579  * in the pin being assumed to be exclusively an input or an output pin.  In
 580  * addition, "input" pins may or may not process the mic bias option
 581  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 582  * accept requests for bias as of chip versions up to March 2006) and/or
 583  * wiring in the computer.
 584  */
 585 #define ALC_PIN_DIR_IN              0x00
 586 #define ALC_PIN_DIR_OUT             0x01
 587 #define ALC_PIN_DIR_INOUT           0x02
 588 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 589 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 590
 591 /* Info about the pin modes supported by the different pin direction modes.
 592  * For each direction the minimum and maximum values are given.
 593  */
 594 static signed char alc_pin_mode_dir_info[5][2] = {
 595         { 0, 2 },    /* ALC_PIN_DIR_IN */
 596         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 597         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 598         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 599         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 600 };
 601 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 602 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 603 #define alc_pin_mode_n_items(_dir) \
 604         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 605
 606 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 607                              struct snd_ctl_elem_info *uinfo)
 608 {
 609         unsigned int item_num = uinfo->value.enumerated.item;
 610         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 611
 612         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 613         uinfo->count = 1;
 614         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 615
 616         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 617                 item_num = alc_pin_mode_min(dir);
 618         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 619         return 0;
 620 }
 621
 622 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 623                             struct snd_ctl_elem_value *ucontrol)
 624 {
 625         unsigned int i;
 626         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 627         hda_nid_t nid = kcontrol->private_value & 0xffff;
 628         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 629         long *valp = ucontrol->value.integer.value;
 630         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 631                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 632                                                  0x00);
 633
 634         /* Find enumerated value for current pinctl setting */
 635         i = alc_pin_mode_min(dir);
 636         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 637                 i++;
 638         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 639         return 0;
 640 }
 641
 642 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 643                             struct snd_ctl_elem_value *ucontrol)
 644 {
 645         signed int change;
 646         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 647         hda_nid_t nid = kcontrol->private_value & 0xffff;
 648         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 649         long val = *ucontrol->value.integer.value;
 650         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 651                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 652                                                  0x00);
 653
 654         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 655                 val = alc_pin_mode_min(dir);
 656
 657         change = pinctl != alc_pin_mode_values[val];
 658         if (change) {
 659                 /* Set pin mode to that requested */
 660                 snd_hda_codec_write_cache(codec, nid, 0,
 661                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 662                                           alc_pin_mode_values[val]);
 663
 664                 /* Also enable the retasking pin's input/output as required
 665                  * for the requested pin mode.  Enum values of 2 or less are
 666                  * input modes.
 667                  *
 668                  * Dynamically switching the input/output buffers probably
 669                  * reduces noise slightly (particularly on input) so we'll
 670                  * do it.  However, having both input and output buffers
 671                  * enabled simultaneously doesn't seem to be problematic if
 672                  * this turns out to be necessary in the future.
 673                  */
 674                 if (val <= 2) {
 675                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 676                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 677                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 678                                                  HDA_AMP_MUTE, 0);
 679                 } else {
 680                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 681                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 682                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 683                                                  HDA_AMP_MUTE, 0);
 684                 }
 685         }
 686         return change;
 687 }
 688
 689 #define ALC_PIN_MODE(xname, nid, dir) \
 690         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 691           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 692           .info = alc_pin_mode_info, \
 693           .get = alc_pin_mode_get, \
 694           .put = alc_pin_mode_put, \
 695           .private_value = nid | (dir<<16) }
 696
 697 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 698  * together using a mask with more than one bit set.  This control is
 699  * currently used only by the ALC260 test model.  At this stage they are not
 700  * needed for any "production" models.
 701  */
 702 #ifdef CONFIG_SND_DEBUG
 703 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 704
 705 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 706                              struct snd_ctl_elem_value *ucontrol)
 707 {
 708         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 709         hda_nid_t nid = kcontrol->private_value & 0xffff;
 710         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 711         long *valp = ucontrol->value.integer.value;
 712         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 713                                               AC_VERB_GET_GPIO_DATA, 0x00);
 714
 715         *valp = (val & mask) != 0;
 716         return 0;
 717 }
 718 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 719                              struct snd_ctl_elem_value *ucontrol)
 720 {
 721         signed int change;
 722         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 723         hda_nid_t nid = kcontrol->private_value & 0xffff;
 724         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 725         long val = *ucontrol->value.integer.value;
 726         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 727                                                     AC_VERB_GET_GPIO_DATA,
 728                                                     0x00);
 729
 730         /* Set/unset the masked GPIO bit(s) as needed */
 731         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 732         if (val == 0)
 733                 gpio_data &= ~mask;
 734         else
 735                 gpio_data |= mask;
 736         snd_hda_codec_write_cache(codec, nid, 0,
 737                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 738
 739         return change;
 740 }
 741 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 742         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 743           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 744           .info = alc_gpio_data_info, \
 745           .get = alc_gpio_data_get, \
 746           .put = alc_gpio_data_put, \
 747           .private_value = nid | (mask<<16) }
 748 #endif   /* CONFIG_SND_DEBUG */
 749
 750 /* A switch control to allow the enabling of the digital IO pins on the
 751  * ALC260.  This is incredibly simplistic; the intention of this control is
 752  * to provide something in the test model allowing digital outputs to be
 753  * identified if present.  If models are found which can utilise these
 754  * outputs a more complete mixer control can be devised for those models if
 755  * necessary.
 756  */
 757 #ifdef CONFIG_SND_DEBUG
 758 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 759
 760 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 761                               struct snd_ctl_elem_value *ucontrol)
 762 {
 763         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 764         hda_nid_t nid = kcontrol->private_value & 0xffff;
 765         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 766         long *valp = ucontrol->value.integer.value;
 767         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 768                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 769
 770         *valp = (val & mask) != 0;
 771         return 0;
 772 }
 773 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 774                               struct snd_ctl_elem_value *ucontrol)
 775 {
 776         signed int change;
 777         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 778         hda_nid_t nid = kcontrol->private_value & 0xffff;
 779         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 780         long val = *ucontrol->value.integer.value;
 781         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 782                                                     AC_VERB_GET_DIGI_CONVERT_1,
 783                                                     0x00);
 784
 785         /* Set/unset the masked control bit(s) as needed */
 786         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 787         if (val==0)
 788                 ctrl_data &= ~mask;
 789         else
 790                 ctrl_data |= mask;
 791         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 792                                   ctrl_data);
 793
 794         return change;
 795 }
 796 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 797         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 798           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 799           .info = alc_spdif_ctrl_info, \
 800           .get = alc_spdif_ctrl_get, \
 801           .put = alc_spdif_ctrl_put, \
 802           .private_value = nid | (mask<<16) }
 803 #endif   /* CONFIG_SND_DEBUG */
 804
 805 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 806  * Again, this is only used in the ALC26x test models to help identify when
 807  * the EAPD line must be asserted for features to work.
 808  */
 809 #ifdef CONFIG_SND_DEBUG
 810 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 811
 812 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 813                               struct snd_ctl_elem_value *ucontrol)
 814 {
 815         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 816         hda_nid_t nid = kcontrol->private_value & 0xffff;
 817         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 818         long *valp = ucontrol->value.integer.value;
 819         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 820                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 821
 822         *valp = (val & mask) != 0;
 823         return 0;
 824 }
 825
 826 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 827                               struct snd_ctl_elem_value *ucontrol)
 828 {
 829         int change;
 830         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 831         hda_nid_t nid = kcontrol->private_value & 0xffff;
 832         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 833         long val = *ucontrol->value.integer.value;
 834         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 835                                                     AC_VERB_GET_EAPD_BTLENABLE,
 836                                                     0x00);
 837
 838         /* Set/unset the masked control bit(s) as needed */
 839         change = (!val ? 0 : mask) != (ctrl_data & mask);
 840         if (!val)
 841                 ctrl_data &= ~mask;
 842         else
 843                 ctrl_data |= mask;
 844         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 845                                   ctrl_data);
 846
 847         return change;
 848 }
 849
 850 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 851         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 852           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 853           .info = alc_eapd_ctrl_info, \
 854           .get = alc_eapd_ctrl_get, \
 855           .put = alc_eapd_ctrl_put, \
 856           .private_value = nid | (mask<<16) }
 857 #endif   /* CONFIG_SND_DEBUG */
 858
 859 /*
 860  * set up the input pin config (depending on the given auto-pin type)
 861  */
 862 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 863                               int auto_pin_type)
 864 {
 865         unsigned int val = PIN_IN;
 866
 867         if (auto_pin_type == AUTO_PIN_MIC) {
 868                 unsigned int pincap;
 869                 unsigned int oldval;
 870                 oldval = snd_hda_codec_read(codec, nid, 0,
 871                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 872                 pincap = snd_hda_query_pin_caps(codec, nid);
 873                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 874                 /* if the default pin setup is vref50, we give it priority */
 875                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 876                         val = PIN_VREF80;
 877                 else if (pincap & AC_PINCAP_VREF_50)
 878                         val = PIN_VREF50;
 879                 else if (pincap & AC_PINCAP_VREF_100)
 880                         val = PIN_VREF100;
 881                 else if (pincap & AC_PINCAP_VREF_GRD)
 882                         val = PIN_VREFGRD;
 883         }
 884         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 885 }
 886
 887 static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
 888 {
 889         struct alc_spec *spec = codec->spec;
 890         struct auto_pin_cfg *cfg = &spec->autocfg;
 891
 892         if (!cfg->line_outs) {
 893                 while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
 894                        cfg->line_out_pins[cfg->line_outs])
 895                         cfg->line_outs++;
 896         }
 897         if (!cfg->speaker_outs) {
 898                 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
 899                        cfg->speaker_pins[cfg->speaker_outs])
 900                         cfg->speaker_outs++;
 901         }
 902         if (!cfg->hp_outs) {
 903                 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
 904                        cfg->hp_pins[cfg->hp_outs])
 905                         cfg->hp_outs++;
 906         }
 907 }
 908
 909 /*
 910  */
 911 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 912 {
 913         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 914                 return;
 915         spec->mixers[spec->num_mixers++] = mix;
 916 }
 917
 918 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 919 {
 920         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 921                 return;
 922         spec->init_verbs[spec->num_init_verbs++] = verb;
 923 }
 924
 925 /*
 926  * set up from the preset table
 927  */
 928 static void setup_preset(struct hda_codec *codec,
 929                          const struct alc_config_preset *preset)
 930 {
 931         struct alc_spec *spec = codec->spec;
 932         int i;
 933
 934         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 935                 add_mixer(spec, preset->mixers[i]);
 936         spec->cap_mixer = preset->cap_mixer;
 937         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 938              i++)
 939                 add_verb(spec, preset->init_verbs[i]);
 940
 941         spec->channel_mode = preset->channel_mode;
 942         spec->num_channel_mode = preset->num_channel_mode;
 943         spec->need_dac_fix = preset->need_dac_fix;
 944         spec->const_channel_count = preset->const_channel_count;
 945
 946         if (preset->const_channel_count)
 947                 spec->multiout.max_channels = preset->const_channel_count;
 948         else
 949                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 950         spec->ext_channel_count = spec->channel_mode[0].channels;
 951
 952         spec->multiout.num_dacs = preset->num_dacs;
 953         spec->multiout.dac_nids = preset->dac_nids;
 954         spec->multiout.dig_out_nid = preset->dig_out_nid;
 955         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 956         spec->multiout.hp_nid = preset->hp_nid;
 957
 958         spec->num_mux_defs = preset->num_mux_defs;
 959         if (!spec->num_mux_defs)
 960                 spec->num_mux_defs = 1;
 961         spec->input_mux = preset->input_mux;
 962
 963         spec->num_adc_nids = preset->num_adc_nids;
 964         spec->adc_nids = preset->adc_nids;
 965         spec->capsrc_nids = preset->capsrc_nids;
 966         spec->dig_in_nid = preset->dig_in_nid;
 967
 968         spec->unsol_event = preset->unsol_event;
 969         spec->init_hook = preset->init_hook;
 970 #ifdef CONFIG_SND_HDA_POWER_SAVE
 971         spec->power_hook = preset->power_hook;
 972         spec->loopback.amplist = preset->loopbacks;
 973 #endif
 974
 975         if (preset->setup)
 976                 preset->setup(codec);
 977
 978         alc_fixup_autocfg_pin_nums(codec);
 979 }
 980
 981 /* Enable GPIO mask and set output */
 982 static struct hda_verb alc_gpio1_init_verbs[] = {
 983         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 984         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 985         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 986         { }
 987 };
 988
 989 static struct hda_verb alc_gpio2_init_verbs[] = {
 990         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 991         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 992         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 993         { }
 994 };
 995
 996 static struct hda_verb alc_gpio3_init_verbs[] = {
 997         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 998         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 999         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
1000         { }
1001 };
1002
1003 /*
1004  * Fix hardware PLL issue
1005  * On some codecs, the analog PLL gating control must be off while
1006  * the default value is 1.
1007  */
1008 static void alc_fix_pll(struct hda_codec *codec)
1009 {
1010         struct alc_spec *spec = codec->spec;
1011         unsigned int val;
1012
1013         if (!spec->pll_nid)
1014                 return;
1015         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1016                             spec->pll_coef_idx);
1017         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1018                                  AC_VERB_GET_PROC_COEF, 0);
1019         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1020                             spec->pll_coef_idx);
1021         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1022                             val & ~(1 << spec->pll_coef_bit));
1023 }
1024
1025 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1026                              unsigned int coef_idx, unsigned int coef_bit)
1027 {
1028         struct alc_spec *spec = codec->spec;
1029         spec->pll_nid = nid;
1030         spec->pll_coef_idx = coef_idx;
1031         spec->pll_coef_bit = coef_bit;
1032         alc_fix_pll(codec);
1033 }
1034
1035 #ifdef CONFIG_SND_HDA_INPUT_JACK
1036 static void alc_free_jack_priv(struct snd_jack *jack)
1037 {
1038         struct alc_jack *jacks = jack->private_data;
1039         jacks->nid = 0;
1040         jacks->jack = NULL;
1041 }
1042
1043 static int alc_add_jack(struct hda_codec *codec,
1044                 hda_nid_t nid, int type)
1045 {
1046         struct alc_spec *spec;
1047         struct alc_jack *jack;
1048         const char *name;
1049         int err;
1050
1051         spec = codec->spec;
1052         snd_array_init(&spec->jacks, sizeof(*jack), 32);
1053         jack = snd_array_new(&spec->jacks);
1054         if (!jack)
1055                 return -ENOMEM;
1056
1057         jack->nid = nid;
1058         jack->type = type;
1059         name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
1060
1061         err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
1062         if (err < 0)
1063                 return err;
1064         jack->jack->private_data = jack;
1065         jack->jack->private_free = alc_free_jack_priv;
1066         return 0;
1067 }
1068
1069 static void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1070 {
1071         struct alc_spec *spec = codec->spec;
1072         struct alc_jack *jacks = spec->jacks.list;
1073
1074         if (jacks) {
1075                 int i;
1076                 for (i = 0; i < spec->jacks.used; i++) {
1077                         if (jacks->nid == nid) {
1078                                 unsigned int present;
1079                                 present = snd_hda_jack_detect(codec, nid);
1080
1081                                 present = (present) ? jacks->type : 0;
1082
1083                                 snd_jack_report(jacks->jack, present);
1084                         }
1085                         jacks++;
1086                 }
1087         }
1088 }
1089
1090 static int alc_init_jacks(struct hda_codec *codec)
1091 {
1092         struct alc_spec *spec = codec->spec;
1093         int err;
1094         unsigned int hp_nid = spec->autocfg.hp_pins[0];
1095         unsigned int mic_nid = spec->ext_mic.pin;
1096
1097         if (hp_nid) {
1098                 err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE);
1099                 if (err < 0)
1100                         return err;
1101                 alc_report_jack(codec, hp_nid);
1102         }
1103
1104         if (mic_nid) {
1105                 err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE);
1106                 if (err < 0)
1107                         return err;
1108                 alc_report_jack(codec, mic_nid);
1109         }
1110
1111         return 0;
1112 }
1113 #else
1114 static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1115 {
1116 }
1117
1118 static inline int alc_init_jacks(struct hda_codec *codec)
1119 {
1120         return 0;
1121 }
1122 #endif
1123
1124 static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1125 {
1126         struct alc_spec *spec = codec->spec;
1127         unsigned int mute;
1128         hda_nid_t nid;
1129         int i;
1130
1131         spec->jack_present = 0;
1132         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1133                 nid = spec->autocfg.hp_pins[i];
1134                 if (!nid)
1135                         break;
1136                 if (snd_hda_jack_detect(codec, nid)) {
1137                         spec->jack_present = 1;
1138                         break;
1139                 }
1140                 alc_report_jack(codec, spec->autocfg.hp_pins[i]);
1141         }
1142
1143         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1144         /* Toggle internal speakers muting */
1145         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1146                 nid = spec->autocfg.speaker_pins[i];
1147                 if (!nid)
1148                         break;
1149                 if (pinctl) {
1150                         snd_hda_codec_write(codec, nid, 0,
1151                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1152                                     spec->jack_present ? 0 : PIN_OUT);
1153                 } else {
1154                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1155                                          HDA_AMP_MUTE, mute);
1156                 }
1157         }
1158 }
1159
1160 static void alc_automute_pin(struct hda_codec *codec)
1161 {
1162         alc_automute_speaker(codec, 1);
1163 }
1164
1165 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1166                                 hda_nid_t nid)
1167 {
1168         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1169         int i, nums;
1170
1171         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1172         for (i = 0; i < nums; i++)
1173                 if (conn[i] == nid)
1174                         return i;
1175         return -1;
1176 }
1177
1178 /* switch the current ADC according to the jack state */
1179 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1180 {
1181         struct alc_spec *spec = codec->spec;
1182         unsigned int present;
1183         hda_nid_t new_adc;
1184
1185         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1186         if (present)
1187                 spec->cur_adc_idx = 1;
1188         else
1189                 spec->cur_adc_idx = 0;
1190         new_adc = spec->adc_nids[spec->cur_adc_idx];
1191         if (spec->cur_adc && spec->cur_adc != new_adc) {
1192                 /* stream is running, let's swap the current ADC */
1193                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1194                 spec->cur_adc = new_adc;
1195                 snd_hda_codec_setup_stream(codec, new_adc,
1196                                            spec->cur_adc_stream_tag, 0,
1197                                            spec->cur_adc_format);
1198         }
1199 }
1200
1201 static void alc_mic_automute(struct hda_codec *codec)
1202 {
1203         struct alc_spec *spec = codec->spec;
1204         struct alc_mic_route *dead, *alive;
1205         unsigned int present, type;
1206         hda_nid_t cap_nid;
1207
1208         if (!spec->auto_mic)
1209                 return;
1210         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1211                 return;
1212         if (snd_BUG_ON(!spec->adc_nids))
1213                 return;
1214
1215         if (spec->dual_adc_switch) {
1216                 alc_dual_mic_adc_auto_switch(codec);
1217                 return;
1218         }
1219
1220         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1221
1222         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1223         if (present) {
1224                 alive = &spec->ext_mic;
1225                 dead = &spec->int_mic;
1226         } else {
1227                 alive = &spec->int_mic;
1228                 dead = &spec->ext_mic;
1229         }
1230
1231         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1232         if (type == AC_WID_AUD_MIX) {
1233                 /* Matrix-mixer style (e.g. ALC882) */
1234                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1235                                          alive->mux_idx,
1236                                          HDA_AMP_MUTE, 0);
1237                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1238                                          dead->mux_idx,
1239                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1240         } else {
1241                 /* MUX style (e.g. ALC880) */
1242                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1243                                           AC_VERB_SET_CONNECT_SEL,
1244                                           alive->mux_idx);
1245         }
1246         alc_report_jack(codec, spec->ext_mic.pin);
1247
1248         /* FIXME: analog mixer */
1249 }
1250
1251 /* unsolicited event for HP jack sensing */
1252 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1253 {
1254         if (codec->vendor_id == 0x10ec0880)
1255                 res >>= 28;
1256         else
1257                 res >>= 26;
1258         switch (res) {
1259         case ALC880_HP_EVENT:
1260                 alc_automute_pin(codec);
1261                 break;
1262         case ALC880_MIC_EVENT:
1263                 alc_mic_automute(codec);
1264                 break;
1265         }
1266 }
1267
1268 static void alc_inithook(struct hda_codec *codec)
1269 {
1270         alc_automute_pin(codec);
1271         alc_mic_automute(codec);
1272 }
1273
1274 /* additional initialization for ALC888 variants */
1275 static void alc888_coef_init(struct hda_codec *codec)
1276 {
1277         unsigned int tmp;
1278
1279         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1280         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1281         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1282         if ((tmp & 0xf0) == 0x20)
1283                 /* alc888S-VC */
1284                 snd_hda_codec_read(codec, 0x20, 0,
1285                                    AC_VERB_SET_PROC_COEF, 0x830);
1286          else
1287                  /* alc888-VB */
1288                  snd_hda_codec_read(codec, 0x20, 0,
1289                                     AC_VERB_SET_PROC_COEF, 0x3030);
1290 }
1291
1292 static void alc889_coef_init(struct hda_codec *codec)
1293 {
1294         unsigned int tmp;
1295
1296         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1297         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1298         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1299         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1300 }
1301
1302 /* turn on/off EAPD control (only if available) */
1303 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1304 {
1305         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1306                 return;
1307         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1308                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1309                                     on ? 2 : 0);
1310 }
1311
1312 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1313 {
1314         unsigned int tmp;
1315
1316         switch (type) {
1317         case ALC_INIT_GPIO1:
1318                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1319                 break;
1320         case ALC_INIT_GPIO2:
1321                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1322                 break;
1323         case ALC_INIT_GPIO3:
1324                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1325                 break;
1326         case ALC_INIT_DEFAULT:
1327                 switch (codec->vendor_id) {
1328                 case 0x10ec0260:
1329                         set_eapd(codec, 0x0f, 1);
1330                         set_eapd(codec, 0x10, 1);
1331                         break;
1332                 case 0x10ec0262:
1333                 case 0x10ec0267:
1334                 case 0x10ec0268:
1335                 case 0x10ec0269:
1336                 case 0x10ec0270:
1337                 case 0x10ec0272:
1338                 case 0x10ec0660:
1339                 case 0x10ec0662:
1340                 case 0x10ec0663:
1341                 case 0x10ec0862:
1342                 case 0x10ec0889:
1343                         set_eapd(codec, 0x14, 1);
1344                         set_eapd(codec, 0x15, 1);
1345                         break;
1346                 }
1347                 switch (codec->vendor_id) {
1348                 case 0x10ec0260:
1349                         snd_hda_codec_write(codec, 0x1a, 0,
1350                                             AC_VERB_SET_COEF_INDEX, 7);
1351                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1352                                                  AC_VERB_GET_PROC_COEF, 0);
1353                         snd_hda_codec_write(codec, 0x1a, 0,
1354                                             AC_VERB_SET_COEF_INDEX, 7);
1355                         snd_hda_codec_write(codec, 0x1a, 0,
1356                                             AC_VERB_SET_PROC_COEF,
1357                                             tmp | 0x2010);
1358                         break;
1359                 case 0x10ec0262:
1360                 case 0x10ec0880:
1361                 case 0x10ec0882:
1362                 case 0x10ec0883:
1363                 case 0x10ec0885:
1364                 case 0x10ec0887:
1365                 case 0x10ec0889:
1366                         alc889_coef_init(codec);
1367                         break;
1368                 case 0x10ec0888:
1369                         alc888_coef_init(codec);
1370                         break;
1371 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1372                 case 0x10ec0267:
1373                 case 0x10ec0268:
1374                         snd_hda_codec_write(codec, 0x20, 0,
1375                                             AC_VERB_SET_COEF_INDEX, 7);
1376                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1377                                                  AC_VERB_GET_PROC_COEF, 0);
1378                         snd_hda_codec_write(codec, 0x20, 0,
1379                                             AC_VERB_SET_COEF_INDEX, 7);
1380                         snd_hda_codec_write(codec, 0x20, 0,
1381                                             AC_VERB_SET_PROC_COEF,
1382                                             tmp | 0x3000);
1383                         break;
1384 #endif /* XXX */
1385                 }
1386                 break;
1387         }
1388 }
1389
1390 static void alc_init_auto_hp(struct hda_codec *codec)
1391 {
1392         struct alc_spec *spec = codec->spec;
1393         struct auto_pin_cfg *cfg = &spec->autocfg;
1394         int i;
1395
1396         if (!cfg->hp_pins[0]) {
1397                 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1398                         return;
1399         }
1400
1401         if (!cfg->speaker_pins[0]) {
1402                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1403                         return;
1404                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1405                        sizeof(cfg->speaker_pins));
1406                 cfg->speaker_outs = cfg->line_outs;
1407         }
1408
1409         if (!cfg->hp_pins[0]) {
1410                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1411                        sizeof(cfg->hp_pins));
1412                 cfg->hp_outs = cfg->line_outs;
1413         }
1414
1415         for (i = 0; i < cfg->hp_outs; i++) {
1416                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1417                             cfg->hp_pins[i]);
1418                 snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1419                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1420                                   AC_USRSP_EN | ALC880_HP_EVENT);
1421         }
1422         spec->unsol_event = alc_sku_unsol_event;
1423 }
1424
1425 static void alc_init_auto_mic(struct hda_codec *codec)
1426 {
1427         struct alc_spec *spec = codec->spec;
1428         struct auto_pin_cfg *cfg = &spec->autocfg;
1429         hda_nid_t fixed, ext;
1430         int i;
1431
1432         /* there must be only two mic inputs exclusively */
1433         for (i = 0; i < cfg->num_inputs; i++)
1434                 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1435                         return;
1436
1437         fixed = ext = 0;
1438         for (i = 0; i < cfg->num_inputs; i++) {
1439                 hda_nid_t nid = cfg->inputs[i].pin;
1440                 unsigned int defcfg;
1441                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1442                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1443                 case INPUT_PIN_ATTR_INT:
1444                         if (fixed)
1445                                 return; /* already occupied */
1446                         fixed = nid;
1447                         break;
1448                 case INPUT_PIN_ATTR_UNUSED:
1449                         return; /* invalid entry */
1450                 default:
1451                         if (ext)
1452                                 return; /* already occupied */
1453                         ext = nid;
1454                         break;
1455                 }
1456         }
1457         if (!ext || !fixed)
1458                 return;
1459         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1460                 return; /* no unsol support */
1461         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1462                     ext, fixed);
1463         spec->ext_mic.pin = ext;
1464         spec->int_mic.pin = fixed;
1465         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1466         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1467         spec->auto_mic = 1;
1468         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1469                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1470                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1471         spec->unsol_event = alc_sku_unsol_event;
1472 }
1473
1474 /* Could be any non-zero and even value. When used as fixup, tells
1475  * the driver to ignore any present sku defines.
1476  */
1477 #define ALC_FIXUP_SKU_IGNORE (2)
1478
1479 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1480 {
1481         unsigned int ass, tmp, i;
1482         unsigned nid = 0;
1483         struct alc_spec *spec = codec->spec;
1484
1485         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1486
1487         if (spec->cdefine.fixup) {
1488                 ass = spec->cdefine.sku_cfg;
1489                 if (ass == ALC_FIXUP_SKU_IGNORE)
1490                         return -1;
1491                 goto do_sku;
1492         }
1493
1494         ass = codec->subsystem_id & 0xffff;
1495         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1496                 goto do_sku;
1497
1498         nid = 0x1d;
1499         if (codec->vendor_id == 0x10ec0260)
1500                 nid = 0x17;
1501         ass = snd_hda_codec_get_pincfg(codec, nid);
1502
1503         if (!(ass & 1)) {
1504                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1505                        codec->chip_name, ass);
1506                 return -1;
1507         }
1508
1509         /* check sum */
1510         tmp = 0;
1511         for (i = 1; i < 16; i++) {
1512                 if ((ass >> i) & 1)
1513                         tmp++;
1514         }
1515         if (((ass >> 16) & 0xf) != tmp)
1516                 return -1;
1517
1518         spec->cdefine.port_connectivity = ass >> 30;
1519         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1520         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1521         spec->cdefine.customization = ass >> 8;
1522 do_sku:
1523         spec->cdefine.sku_cfg = ass;
1524         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1525         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1526         spec->cdefine.swap = (ass & 0x2) >> 1;
1527         spec->cdefine.override = ass & 0x1;
1528
1529         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1530                    nid, spec->cdefine.sku_cfg);
1531         snd_printd("SKU: port_connectivity=0x%x\n",
1532                    spec->cdefine.port_connectivity);
1533         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1534         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1535         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1536         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1537         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1538         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1539         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1540
1541         return 0;
1542 }
1543
1544 /* check subsystem ID and set up device-specific initialization;
1545  * return 1 if initialized, 0 if invalid SSID
1546  */
1547 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1548  *      31 ~ 16 :       Manufacture ID
1549  *      15 ~ 8  :       SKU ID
1550  *      7  ~ 0  :       Assembly ID
1551  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1552  */
1553 static int alc_subsystem_id(struct hda_codec *codec,
1554                             hda_nid_t porta, hda_nid_t porte,
1555                             hda_nid_t portd, hda_nid_t porti)
1556 {
1557         unsigned int ass, tmp, i;
1558         unsigned nid;
1559         struct alc_spec *spec = codec->spec;
1560
1561         if (spec->cdefine.fixup) {
1562                 ass = spec->cdefine.sku_cfg;
1563                 if (ass == ALC_FIXUP_SKU_IGNORE)
1564                         return 0;
1565                 goto do_sku;
1566         }
1567
1568         ass = codec->subsystem_id & 0xffff;
1569         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1570                 goto do_sku;
1571
1572         /* invalid SSID, check the special NID pin defcfg instead */
1573         /*
1574          * 31~30        : port connectivity
1575          * 29~21        : reserve
1576          * 20           : PCBEEP input
1577          * 19~16        : Check sum (15:1)
1578          * 15~1         : Custom
1579          * 0            : override
1580         */
1581         nid = 0x1d;
1582         if (codec->vendor_id == 0x10ec0260)
1583                 nid = 0x17;
1584         ass = snd_hda_codec_get_pincfg(codec, nid);
1585         snd_printd("realtek: No valid SSID, "
1586                    "checking pincfg 0x%08x for NID 0x%x\n",
1587                    ass, nid);
1588         if (!(ass & 1))
1589                 return 0;
1590         if ((ass >> 30) != 1)   /* no physical connection */
1591                 return 0;
1592
1593         /* check sum */
1594         tmp = 0;
1595         for (i = 1; i < 16; i++) {
1596                 if ((ass >> i) & 1)
1597                         tmp++;
1598         }
1599         if (((ass >> 16) & 0xf) != tmp)
1600                 return 0;
1601 do_sku:
1602         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1603                    ass & 0xffff, codec->vendor_id);
1604         /*
1605          * 0 : override
1606          * 1 :  Swap Jack
1607          * 2 : 0 --> Desktop, 1 --> Laptop
1608          * 3~5 : External Amplifier control
1609          * 7~6 : Reserved
1610         */
1611         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1612         switch (tmp) {
1613         case 1:
1614                 spec->init_amp = ALC_INIT_GPIO1;
1615                 break;
1616         case 3:
1617                 spec->init_amp = ALC_INIT_GPIO2;
1618                 break;
1619         case 7:
1620                 spec->init_amp = ALC_INIT_GPIO3;
1621                 break;
1622         case 5:
1623         default:
1624                 spec->init_amp = ALC_INIT_DEFAULT;
1625                 break;
1626         }
1627
1628         /* is laptop or Desktop and enable the function "Mute internal speaker
1629          * when the external headphone out jack is plugged"
1630          */
1631         if (!(ass & 0x8000))
1632                 return 1;
1633         /*
1634          * 10~8 : Jack location
1635          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1636          * 14~13: Resvered
1637          * 15   : 1 --> enable the function "Mute internal speaker
1638          *              when the external headphone out jack is plugged"
1639          */
1640         if (!spec->autocfg.hp_pins[0]) {
1641                 hda_nid_t nid;
1642                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1643                 if (tmp == 0)
1644                         nid = porta;
1645                 else if (tmp == 1)
1646                         nid = porte;
1647                 else if (tmp == 2)
1648                         nid = portd;
1649                 else if (tmp == 3)
1650                         nid = porti;
1651                 else
1652                         return 1;
1653                 for (i = 0; i < spec->autocfg.line_outs; i++)
1654                         if (spec->autocfg.line_out_pins[i] == nid)
1655                                 return 1;
1656                 spec->autocfg.hp_pins[0] = nid;
1657         }
1658
1659         alc_init_auto_hp(codec);
1660         alc_init_auto_mic(codec);
1661         return 1;
1662 }
1663
1664 static void alc_ssid_check(struct hda_codec *codec,
1665                            hda_nid_t porta, hda_nid_t porte,
1666                            hda_nid_t portd, hda_nid_t porti)
1667 {
1668         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1669                 struct alc_spec *spec = codec->spec;
1670                 snd_printd("realtek: "
1671                            "Enable default setup for auto mode as fallback\n");
1672                 spec->init_amp = ALC_INIT_DEFAULT;
1673                 alc_init_auto_hp(codec);
1674                 alc_init_auto_mic(codec);
1675         }
1676 }
1677
1678 /*
1679  * Fix-up pin default configurations and add default verbs
1680  */
1681
1682 struct alc_pincfg {
1683         hda_nid_t nid;
1684         u32 val;
1685 };
1686
1687 struct alc_model_fixup {
1688         const int id;
1689         const char *name;
1690 };
1691
1692 struct alc_fixup {
1693         int type;
1694         bool chained;
1695         int chain_id;
1696         union {
1697                 unsigned int sku;
1698                 const struct alc_pincfg *pins;
1699                 const struct hda_verb *verbs;
1700                 void (*func)(struct hda_codec *codec,
1701                              const struct alc_fixup *fix,
1702                              int action);
1703         } v;
1704 };
1705
1706 enum {
1707         ALC_FIXUP_INVALID,
1708         ALC_FIXUP_SKU,
1709         ALC_FIXUP_PINS,
1710         ALC_FIXUP_VERBS,
1711         ALC_FIXUP_FUNC,
1712 };
1713
1714 enum {
1715         ALC_FIXUP_ACT_PRE_PROBE,
1716         ALC_FIXUP_ACT_PROBE,
1717         ALC_FIXUP_ACT_INIT,
1718 };
1719
1720 static void alc_apply_fixup(struct hda_codec *codec, int action)
1721 {
1722         struct alc_spec *spec = codec->spec;
1723         int id = spec->fixup_id;
1724         const char *modelname = spec->fixup_name;
1725         int depth = 0;
1726
1727         if (!spec->fixup_list)
1728                 return;
1729
1730         while (id >= 0) {
1731                 const struct alc_fixup *fix = spec->fixup_list + id;
1732                 const struct alc_pincfg *cfg;
1733
1734                 switch (fix->type) {
1735                 case ALC_FIXUP_SKU:
1736                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1737                                 break;;
1738                         snd_printdd(KERN_INFO "hda_codec: %s: "
1739                                     "Apply sku override for %s\n",
1740                                     codec->chip_name, modelname);
1741                         spec->cdefine.sku_cfg = fix->v.sku;
1742                         spec->cdefine.fixup = 1;
1743                         break;
1744                 case ALC_FIXUP_PINS:
1745                         cfg = fix->v.pins;
1746                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1747                                 break;
1748                         snd_printdd(KERN_INFO "hda_codec: %s: "
1749                                     "Apply pincfg for %s\n",
1750                                     codec->chip_name, modelname);
1751                         for (; cfg->nid; cfg++)
1752                                 snd_hda_codec_set_pincfg(codec, cfg->nid,
1753                                                          cfg->val);
1754                         break;
1755                 case ALC_FIXUP_VERBS:
1756                         if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1757                                 break;
1758                         snd_printdd(KERN_INFO "hda_codec: %s: "
1759                                     "Apply fix-verbs for %s\n",
1760                                     codec->chip_name, modelname);
1761                         add_verb(codec->spec, fix->v.verbs);
1762                         break;
1763                 case ALC_FIXUP_FUNC:
1764                         if (!fix->v.func)
1765                                 break;
1766                         snd_printdd(KERN_INFO "hda_codec: %s: "
1767                                     "Apply fix-func for %s\n",
1768                                     codec->chip_name, modelname);
1769                         fix->v.func(codec, fix, action);
1770                         break;
1771                 default:
1772                         snd_printk(KERN_ERR "hda_codec: %s: "
1773                                    "Invalid fixup type %d\n",
1774                                    codec->chip_name, fix->type);
1775                         break;
1776                 }
1777                 if (!fix[id].chained)
1778                         break;
1779                 if (++depth > 10)
1780                         break;
1781                 id = fix[id].chain_id;
1782         }
1783 }
1784
1785 static void alc_pick_fixup(struct hda_codec *codec,
1786                            const struct alc_model_fixup *models,
1787                            const struct snd_pci_quirk *quirk,
1788                            const struct alc_fixup *fixlist)
1789 {
1790         struct alc_spec *spec = codec->spec;
1791         int id = -1;
1792         const char *name = NULL;
1793
1794         if (codec->modelname && models) {
1795                 while (models->name) {
1796                         if (!strcmp(codec->modelname, models->name)) {
1797                                 id = models->id;
1798                                 name = models->name;
1799                                 break;
1800                         }
1801                         models++;
1802                 }
1803         }
1804         if (id < 0) {
1805                 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1806                 if (quirk) {
1807                         id = quirk->value;
1808 #ifdef CONFIG_SND_DEBUG_VERBOSE
1809                         name = quirk->name;
1810 #endif
1811                 }
1812         }
1813
1814         spec->fixup_id = id;
1815         if (id >= 0) {
1816                 spec->fixup_list = fixlist;
1817                 spec->fixup_name = name;
1818         }
1819 }
1820
1821 static int alc_read_coef_idx(struct hda_codec *codec,
1822                         unsigned int coef_idx)
1823 {
1824         unsigned int val;
1825         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1826                                 coef_idx);
1827         val = snd_hda_codec_read(codec, 0x20, 0,
1828                                 AC_VERB_GET_PROC_COEF, 0);
1829         return val;
1830 }
1831
1832 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1833                                                         unsigned int coef_val)
1834 {
1835         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1836                             coef_idx);
1837         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1838                             coef_val);
1839 }
1840
1841 /* set right pin controls for digital I/O */
1842 static void alc_auto_init_digital(struct hda_codec *codec)
1843 {
1844         struct alc_spec *spec = codec->spec;
1845         int i;
1846         hda_nid_t pin;
1847
1848         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1849                 pin = spec->autocfg.dig_out_pins[i];
1850                 if (pin) {
1851                         snd_hda_codec_write(codec, pin, 0,
1852                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1853                                             PIN_OUT);
1854                 }
1855         }
1856         pin = spec->autocfg.dig_in_pin;
1857         if (pin)
1858                 snd_hda_codec_write(codec, pin, 0,
1859                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1860                                     PIN_IN);
1861 }
1862
1863 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1864 static void alc_auto_parse_digital(struct hda_codec *codec)
1865 {
1866         struct alc_spec *spec = codec->spec;
1867         int i, err;
1868         hda_nid_t dig_nid;
1869
1870         /* support multiple SPDIFs; the secondary is set up as a slave */
1871         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1872                 err = snd_hda_get_connections(codec,
1873                                               spec->autocfg.dig_out_pins[i],
1874                                               &dig_nid, 1);
1875                 if (err < 0)
1876                         continue;
1877                 if (!i) {
1878                         spec->multiout.dig_out_nid = dig_nid;
1879                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1880                 } else {
1881                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1882                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1883                                 break;
1884                         spec->slave_dig_outs[i - 1] = dig_nid;
1885                 }
1886         }
1887
1888         if (spec->autocfg.dig_in_pin) {
1889                 dig_nid = codec->start_nid;
1890                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1891                         unsigned int wcaps = get_wcaps(codec, dig_nid);
1892                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1893                                 continue;
1894                         if (!(wcaps & AC_WCAP_DIGITAL))
1895                                 continue;
1896                         if (!(wcaps & AC_WCAP_CONN_LIST))
1897                                 continue;
1898                         err = get_connection_index(codec, dig_nid,
1899                                                    spec->autocfg.dig_in_pin);
1900                         if (err >= 0) {
1901                                 spec->dig_in_nid = dig_nid;
1902                                 break;
1903                         }
1904                 }
1905         }
1906 }
1907
1908 /*
1909  * ALC888
1910  */
1911
1912 /*
1913  * 2ch mode
1914  */
1915 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1916 /* Mic-in jack as mic in */
1917         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1918         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1919 /* Line-in jack as Line in */
1920         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1921         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1922 /* Line-Out as Front */
1923         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1924         { } /* end */
1925 };
1926
1927 /*
1928  * 4ch mode
1929  */
1930 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1931 /* Mic-in jack as mic in */
1932         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1933         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1934 /* Line-in jack as Surround */
1935         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1936         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1937 /* Line-Out as Front */
1938         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1939         { } /* end */
1940 };
1941
1942 /*
1943  * 6ch mode
1944  */
1945 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1946 /* Mic-in jack as CLFE */
1947         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1948         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1949 /* Line-in jack as Surround */
1950         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1951         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1952 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1953         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1954         { } /* end */
1955 };
1956
1957 /*
1958  * 8ch mode
1959  */
1960 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1961 /* Mic-in jack as CLFE */
1962         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1963         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1964 /* Line-in jack as Surround */
1965         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1966         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1967 /* Line-Out as Side */
1968         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1969         { } /* end */
1970 };
1971
1972 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1973         { 2, alc888_4ST_ch2_intel_init },
1974         { 4, alc888_4ST_ch4_intel_init },
1975         { 6, alc888_4ST_ch6_intel_init },
1976         { 8, alc888_4ST_ch8_intel_init },
1977 };
1978
1979 /*
1980  * ALC888 Fujitsu Siemens Amillo xa3530
1981  */
1982
1983 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1984 /* Front Mic: set to PIN_IN (empty by default) */
1985         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1986 /* Connect Internal HP to Front */
1987         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1988         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1989         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1990 /* Connect Bass HP to Front */
1991         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1992         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1993         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1994 /* Connect Line-Out side jack (SPDIF) to Side */
1995         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1996         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1997         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1998 /* Connect Mic jack to CLFE */
1999         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2000         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2001         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
2002 /* Connect Line-in jack to Surround */
2003         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2004         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2005         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
2006 /* Connect HP out jack to Front */
2007         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2008         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2009         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2010 /* Enable unsolicited event for HP jack and Line-out jack */
2011         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2012         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2013         {}
2014 };
2015
2016 static void alc_automute_amp(struct hda_codec *codec)
2017 {
2018         alc_automute_speaker(codec, 0);
2019 }
2020
2021 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
2022                                          unsigned int res)
2023 {
2024         if (codec->vendor_id == 0x10ec0880)
2025                 res >>= 28;
2026         else
2027                 res >>= 26;
2028         if (res == ALC880_HP_EVENT)
2029                 alc_automute_amp(codec);
2030 }
2031
2032 static void alc889_automute_setup(struct hda_codec *codec)
2033 {
2034         struct alc_spec *spec = codec->spec;
2035
2036         spec->autocfg.hp_pins[0] = 0x15;
2037         spec->autocfg.speaker_pins[0] = 0x14;
2038         spec->autocfg.speaker_pins[1] = 0x16;
2039         spec->autocfg.speaker_pins[2] = 0x17;
2040         spec->autocfg.speaker_pins[3] = 0x19;
2041         spec->autocfg.speaker_pins[4] = 0x1a;
2042 }
2043
2044 static void alc889_intel_init_hook(struct hda_codec *codec)
2045 {
2046         alc889_coef_init(codec);
2047         alc_automute_amp(codec);
2048 }
2049
2050 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
2051 {
2052         struct alc_spec *spec = codec->spec;
2053
2054         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
2055         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
2056         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
2057         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
2058 }
2059
2060 /*
2061  * ALC888 Acer Aspire 4930G model
2062  */
2063
2064 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
2065 /* Front Mic: set to PIN_IN (empty by default) */
2066         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2067 /* Unselect Front Mic by default in input mixer 3 */
2068         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2069 /* Enable unsolicited event for HP jack */
2070         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2071 /* Connect Internal HP to front */
2072         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2073         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2074         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2075 /* Connect HP out to front */
2076         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2077         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2078         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2079         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2080         { }
2081 };
2082
2083 /*
2084  * ALC888 Acer Aspire 6530G model
2085  */
2086
2087 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2088 /* Route to built-in subwoofer as well as speakers */
2089         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2090         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2091         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2092         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2093 /* Bias voltage on for external mic port */
2094         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2095 /* Front Mic: set to PIN_IN (empty by default) */
2096         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2097 /* Unselect Front Mic by default in input mixer 3 */
2098         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2099 /* Enable unsolicited event for HP jack */
2100         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2101 /* Enable speaker output */
2102         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2103         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2104         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2105 /* Enable headphone output */
2106         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2107         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2108         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2109         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2110         { }
2111 };
2112
2113 /*
2114  *ALC888 Acer Aspire 7730G model
2115  */
2116
2117 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2118 /* Bias voltage on for external mic port */
2119         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2120 /* Front Mic: set to PIN_IN (empty by default) */
2121         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2122 /* Unselect Front Mic by default in input mixer 3 */
2123         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2124 /* Enable unsolicited event for HP jack */
2125         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2126 /* Enable speaker output */
2127         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2128         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2129         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2130 /* Enable headphone output */
2131         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2132         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2133         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2134         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2135 /*Enable internal subwoofer */
2136         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2137         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2138         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2139         {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2140         { }
2141 };
2142
2143 /*
2144  * ALC889 Acer Aspire 8930G model
2145  */
2146
2147 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2148 /* Front Mic: set to PIN_IN (empty by default) */
2149         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2150 /* Unselect Front Mic by default in input mixer 3 */
2151         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2152 /* Enable unsolicited event for HP jack */
2153         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2154 /* Connect Internal Front to Front */
2155         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2156         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2157         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2158 /* Connect Internal Rear to Rear */
2159         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2160         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2161         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2162 /* Connect Internal CLFE to CLFE */
2163         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2164         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2165         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2166 /* Connect HP out to Front */
2167         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2168         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2169         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2170 /* Enable all DACs */
2171 /*  DAC DISABLE/MUTE 1? */
2172 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2173         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2174         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2175 /*  DAC DISABLE/MUTE 2? */
2176 /*  some bit here disables the other DACs. Init=0x4900 */
2177         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2178         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2179 /* DMIC fix
2180  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2181  * which makes the stereo useless. However, either the mic or the ALC889
2182  * makes the signal become a difference/sum signal instead of standard
2183  * stereo, which is annoying. So instead we flip this bit which makes the
2184  * codec replicate the sum signal to both channels, turning it into a
2185  * normal mono mic.
2186  */
2187 /*  DMIC_CONTROL? Init value = 0x0001 */
2188         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2189         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2190         { }
2191 };
2192
2193 static struct hda_input_mux alc888_2_capture_sources[2] = {
2194         /* Front mic only available on one ADC */
2195         {
2196                 .num_items = 4,
2197                 .items = {
2198                         { "Mic", 0x0 },
2199                         { "Line", 0x2 },
2200                         { "CD", 0x4 },
2201                         { "Front Mic", 0xb },
2202                 },
2203         },
2204         {
2205                 .num_items = 3,
2206                 .items = {
2207                         { "Mic", 0x0 },
2208                         { "Line", 0x2 },
2209                         { "CD", 0x4 },
2210                 },
2211         }
2212 };
2213
2214 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2215         /* Interal mic only available on one ADC */
2216         {
2217                 .num_items = 5,
2218                 .items = {
2219                         { "Mic", 0x0 },
2220                         { "Line In", 0x2 },
2221                         { "CD", 0x4 },
2222                         { "Input Mix", 0xa },
2223                         { "Internal Mic", 0xb },
2224                 },
2225         },
2226         {
2227                 .num_items = 4,
2228                 .items = {
2229                         { "Mic", 0x0 },
2230                         { "Line In", 0x2 },
2231                         { "CD", 0x4 },
2232                         { "Input Mix", 0xa },
2233                 },
2234         }
2235 };
2236
2237 static struct hda_input_mux alc889_capture_sources[3] = {
2238         /* Digital mic only available on first "ADC" */
2239         {
2240                 .num_items = 5,
2241                 .items = {
2242                         { "Mic", 0x0 },
2243                         { "Line", 0x2 },
2244                         { "CD", 0x4 },
2245                         { "Front Mic", 0xb },
2246                         { "Input Mix", 0xa },
2247                 },
2248         },
2249         {
2250                 .num_items = 4,
2251                 .items = {
2252                         { "Mic", 0x0 },
2253                         { "Line", 0x2 },
2254                         { "CD", 0x4 },
2255                         { "Input Mix", 0xa },
2256                 },
2257         },
2258         {
2259                 .num_items = 4,
2260                 .items = {
2261                         { "Mic", 0x0 },
2262                         { "Line", 0x2 },
2263                         { "CD", 0x4 },
2264                         { "Input Mix", 0xa },
2265                 },
2266         }
2267 };
2268
2269 static struct snd_kcontrol_new alc888_base_mixer[] = {
2270         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2271         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2272         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2273         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2274         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2275                 HDA_OUTPUT),
2276         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2277         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2278         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2279         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2280         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2281         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2282         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2283         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2284         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2285         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2286         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2287         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2288         { } /* end */
2289 };
2290
2291 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2292         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2293         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2294         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2295         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2296         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2297                 HDA_OUTPUT),
2298         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2299         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2300         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2301         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2302         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2303         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2304         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2305         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2306         { } /* end */
2307 };
2308
2309
2310 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2311 {
2312         struct alc_spec *spec = codec->spec;
2313
2314         spec->autocfg.hp_pins[0] = 0x15;
2315         spec->autocfg.speaker_pins[0] = 0x14;
2316         spec->autocfg.speaker_pins[1] = 0x16;
2317         spec->autocfg.speaker_pins[2] = 0x17;
2318 }
2319
2320 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2321 {
2322         struct alc_spec *spec = codec->spec;
2323
2324         spec->autocfg.hp_pins[0] = 0x15;
2325         spec->autocfg.speaker_pins[0] = 0x14;
2326         spec->autocfg.speaker_pins[1] = 0x16;
2327         spec->autocfg.speaker_pins[2] = 0x17;
2328 }
2329
2330 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2331 {
2332         struct alc_spec *spec = codec->spec;
2333
2334         spec->autocfg.hp_pins[0] = 0x15;
2335         spec->autocfg.speaker_pins[0] = 0x14;
2336         spec->autocfg.speaker_pins[1] = 0x16;
2337         spec->autocfg.speaker_pins[2] = 0x17;
2338 }
2339
2340 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2341 {
2342         struct alc_spec *spec = codec->spec;
2343
2344         spec->autocfg.hp_pins[0] = 0x15;
2345         spec->autocfg.speaker_pins[0] = 0x14;
2346         spec->autocfg.speaker_pins[1] = 0x16;
2347         spec->autocfg.speaker_pins[2] = 0x1b;
2348 }
2349
2350 /*
2351  * ALC880 3-stack model
2352  *
2353  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2354  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2355  *                 F-Mic = 0x1b, HP = 0x19
2356  */
2357
2358 static hda_nid_t alc880_dac_nids[4] = {
2359         /* front, rear, clfe, rear_surr */
2360         0x02, 0x05, 0x04, 0x03
2361 };
2362
2363 static hda_nid_t alc880_adc_nids[3] = {
2364         /* ADC0-2 */
2365         0x07, 0x08, 0x09,
2366 };
2367
2368 /* The datasheet says the node 0x07 is connected from inputs,
2369  * but it shows zero connection in the real implementation on some devices.
2370  * Note: this is a 915GAV bug, fixed on 915GLV
2371  */
2372 static hda_nid_t alc880_adc_nids_alt[2] = {
2373         /* ADC1-2 */
2374         0x08, 0x09,
2375 };
2376
2377 #define ALC880_DIGOUT_NID       0x06
2378 #define ALC880_DIGIN_NID        0x0a
2379
2380 static struct hda_input_mux alc880_capture_source = {
2381         .num_items = 4,
2382         .items = {
2383                 { "Mic", 0x0 },
2384                 { "Front Mic", 0x3 },
2385                 { "Line", 0x2 },
2386                 { "CD", 0x4 },
2387         },
2388 };
2389
2390 /* channel source setting (2/6 channel selection for 3-stack) */
2391 /* 2ch mode */
2392 static struct hda_verb alc880_threestack_ch2_init[] = {
2393         /* set line-in to input, mute it */
2394         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2395         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2396         /* set mic-in to input vref 80%, mute it */
2397         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2398         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2399         { } /* end */
2400 };
2401
2402 /* 6ch mode */
2403 static struct hda_verb alc880_threestack_ch6_init[] = {
2404         /* set line-in to output, unmute it */
2405         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2406         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2407         /* set mic-in to output, unmute it */
2408         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2409         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2410         { } /* end */
2411 };
2412
2413 static struct hda_channel_mode alc880_threestack_modes[2] = {
2414         { 2, alc880_threestack_ch2_init },
2415         { 6, alc880_threestack_ch6_init },
2416 };
2417
2418 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2419         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2420         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2421         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2422         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2423         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2424         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2425         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2426         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2427         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2428         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2429         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2430         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2431         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2432         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2433         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2434         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2435         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2436         {
2437                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2438                 .name = "Channel Mode",
2439                 .info = alc_ch_mode_info,
2440                 .get = alc_ch_mode_get,
2441                 .put = alc_ch_mode_put,
2442         },
2443         { } /* end */
2444 };
2445
2446 /* capture mixer elements */
2447 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2448                             struct snd_ctl_elem_info *uinfo)
2449 {
2450         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2451         struct alc_spec *spec = codec->spec;
2452         int err;
2453
2454         mutex_lock(&codec->control_mutex);
2455         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2456                                                       HDA_INPUT);
2457         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2458         mutex_unlock(&codec->control_mutex);
2459         return err;
2460 }
2461
2462 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2463                            unsigned int size, unsigned int __user *tlv)
2464 {
2465         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2466         struct alc_spec *spec = codec->spec;
2467         int err;
2468
2469         mutex_lock(&codec->control_mutex);
2470         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2471                                                       HDA_INPUT);
2472         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2473         mutex_unlock(&codec->control_mutex);
2474         return err;
2475 }
2476
2477 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2478                              struct snd_ctl_elem_value *ucontrol);
2479
2480 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2481                                  struct snd_ctl_elem_value *ucontrol,
2482                                  getput_call_t func)
2483 {
2484         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2485         struct alc_spec *spec = codec->spec;
2486         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2487         int err;
2488
2489         mutex_lock(&codec->control_mutex);
2490         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2491                                                       3, 0, HDA_INPUT);
2492         err = func(kcontrol, ucontrol);
2493         mutex_unlock(&codec->control_mutex);
2494         return err;
2495 }
2496
2497 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2498                            struct snd_ctl_elem_value *ucontrol)
2499 {
2500         return alc_cap_getput_caller(kcontrol, ucontrol,
2501                                      snd_hda_mixer_amp_volume_get);
2502 }
2503
2504 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2505                            struct snd_ctl_elem_value *ucontrol)
2506 {
2507         return alc_cap_getput_caller(kcontrol, ucontrol,
2508                                      snd_hda_mixer_amp_volume_put);
2509 }
2510
2511 /* capture mixer elements */
2512 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2513
2514 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2515                           struct snd_ctl_elem_value *ucontrol)
2516 {
2517         return alc_cap_getput_caller(kcontrol, ucontrol,
2518                                      snd_hda_mixer_amp_switch_get);
2519 }
2520
2521 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2522                           struct snd_ctl_elem_value *ucontrol)
2523 {
2524         return alc_cap_getput_caller(kcontrol, ucontrol,
2525                                      snd_hda_mixer_amp_switch_put);
2526 }
2527
2528 #define _DEFINE_CAPMIX(num) \
2529         { \
2530                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2531                 .name = "Capture Switch", \
2532                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2533                 .count = num, \
2534                 .info = alc_cap_sw_info, \
2535                 .get = alc_cap_sw_get, \
2536                 .put = alc_cap_sw_put, \
2537         }, \
2538         { \
2539                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2540                 .name = "Capture Volume", \
2541                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2542                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2543                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2544                 .count = num, \
2545                 .info = alc_cap_vol_info, \
2546                 .get = alc_cap_vol_get, \
2547                 .put = alc_cap_vol_put, \
2548                 .tlv = { .c = alc_cap_vol_tlv }, \
2549         }
2550
2551 #define _DEFINE_CAPSRC(num) \
2552         { \
2553                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2554                 /* .name = "Capture Source", */ \
2555                 .name = "Input Source", \
2556                 .count = num, \
2557                 .info = alc_mux_enum_info, \
2558                 .get = alc_mux_enum_get, \
2559                 .put = alc_mux_enum_put, \
2560         }
2561
2562 #define DEFINE_CAPMIX(num) \
2563 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2564         _DEFINE_CAPMIX(num),                                  \
2565         _DEFINE_CAPSRC(num),                                  \
2566         { } /* end */                                         \
2567 }
2568
2569 #define DEFINE_CAPMIX_NOSRC(num) \
2570 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2571         _DEFINE_CAPMIX(num),                                        \
2572         { } /* end */                                               \
2573 }
2574
2575 /* up to three ADCs */
2576 DEFINE_CAPMIX(1);
2577 DEFINE_CAPMIX(2);
2578 DEFINE_CAPMIX(3);
2579 DEFINE_CAPMIX_NOSRC(1);
2580 DEFINE_CAPMIX_NOSRC(2);
2581 DEFINE_CAPMIX_NOSRC(3);
2582
2583 /*
2584  * ALC880 5-stack model
2585  *
2586  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2587  *      Side = 0x02 (0xd)
2588  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2589  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2590  */
2591
2592 /* additional mixers to alc880_three_stack_mixer */
2593 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2594         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2595         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2596         { } /* end */
2597 };
2598
2599 /* channel source setting (6/8 channel selection for 5-stack) */
2600 /* 6ch mode */
2601 static struct hda_verb alc880_fivestack_ch6_init[] = {
2602         /* set line-in to input, mute it */
2603         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2604         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2605         { } /* end */
2606 };
2607
2608 /* 8ch mode */
2609 static struct hda_verb alc880_fivestack_ch8_init[] = {
2610         /* set line-in to output, unmute it */
2611         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2612         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2613         { } /* end */
2614 };
2615
2616 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2617         { 6, alc880_fivestack_ch6_init },
2618         { 8, alc880_fivestack_ch8_init },
2619 };
2620
2621
2622 /*
2623  * ALC880 6-stack model
2624  *
2625  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2626  *      Side = 0x05 (0x0f)
2627  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2628  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2629  */
2630
2631 static hda_nid_t alc880_6st_dac_nids[4] = {
2632         /* front, rear, clfe, rear_surr */
2633         0x02, 0x03, 0x04, 0x05
2634 };
2635
2636 static struct hda_input_mux alc880_6stack_capture_source = {
2637         .num_items = 4,
2638         .items = {
2639                 { "Mic", 0x0 },
2640                 { "Front Mic", 0x1 },
2641                 { "Line", 0x2 },
2642                 { "CD", 0x4 },
2643         },
2644 };
2645
2646 /* fixed 8-channels */
2647 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2648         { 8, NULL },
2649 };
2650
2651 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2652         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2653         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2654         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2655         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2656         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2657         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2658         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2659         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2660         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2661         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2662         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2663         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2664         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2665         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2666         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2667         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2668         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2669         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2670         {
2671                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2672                 .name = "Channel Mode",
2673                 .info = alc_ch_mode_info,
2674                 .get = alc_ch_mode_get,
2675                 .put = alc_ch_mode_put,
2676         },
2677         { } /* end */
2678 };
2679
2680
2681 /*
2682  * ALC880 W810 model
2683  *
2684  * W810 has rear IO for:
2685  * Front (DAC 02)
2686  * Surround (DAC 03)
2687  * Center/LFE (DAC 04)
2688  * Digital out (06)
2689  *
2690  * The system also has a pair of internal speakers, and a headphone jack.
2691  * These are both connected to Line2 on the codec, hence to DAC 02.
2692  *
2693  * There is a variable resistor to control the speaker or headphone
2694  * volume. This is a hardware-only device without a software API.
2695  *
2696  * Plugging headphones in will disable the internal speakers. This is
2697  * implemented in hardware, not via the driver using jack sense. In
2698  * a similar fashion, plugging into the rear socket marked "front" will
2699  * disable both the speakers and headphones.
2700  *
2701  * For input, there's a microphone jack, and an "audio in" jack.
2702  * These may not do anything useful with this driver yet, because I
2703  * haven't setup any initialization verbs for these yet...
2704  */
2705
2706 static hda_nid_t alc880_w810_dac_nids[3] = {
2707         /* front, rear/surround, clfe */
2708         0x02, 0x03, 0x04
2709 };
2710
2711 /* fixed 6 channels */
2712 static struct hda_channel_mode alc880_w810_modes[1] = {
2713         { 6, NULL }
2714 };
2715
2716 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2717 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2718         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2719         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2720         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2721         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2722         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2723         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2724         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2725         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2726         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2727         { } /* end */
2728 };
2729
2730
2731 /*
2732  * Z710V model
2733  *
2734  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2735  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2736  *                 Line = 0x1a
2737  */
2738
2739 static hda_nid_t alc880_z71v_dac_nids[1] = {
2740         0x02
2741 };
2742 #define ALC880_Z71V_HP_DAC      0x03
2743
2744 /* fixed 2 channels */
2745 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2746         { 2, NULL }
2747 };
2748
2749 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2750         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2751         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2752         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2753         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2754         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2755         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2756         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2757         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2758         { } /* end */
2759 };
2760
2761
2762 /*
2763  * ALC880 F1734 model
2764  *
2765  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2766  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2767  */
2768
2769 static hda_nid_t alc880_f1734_dac_nids[1] = {
2770         0x03
2771 };
2772 #define ALC880_F1734_HP_DAC     0x02
2773
2774 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2775         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2776         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2777         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2778         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2779         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2780         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2781         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2782         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2783         { } /* end */
2784 };
2785
2786 static struct hda_input_mux alc880_f1734_capture_source = {
2787         .num_items = 2,
2788         .items = {
2789                 { "Mic", 0x1 },
2790                 { "CD", 0x4 },
2791         },
2792 };
2793
2794
2795 /*
2796  * ALC880 ASUS model
2797  *
2798  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2799  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2800  *  Mic = 0x18, Line = 0x1a
2801  */
2802
2803 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2804 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2805
2806 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2807         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2808         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2809         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2810         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2811         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2812         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2813         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2814         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2815         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2816         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2817         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2818         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2819         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2820         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2821         {
2822                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2823                 .name = "Channel Mode",
2824                 .info = alc_ch_mode_info,
2825                 .get = alc_ch_mode_get,
2826                 .put = alc_ch_mode_put,
2827         },
2828         { } /* end */
2829 };
2830
2831 /*
2832  * ALC880 ASUS W1V model
2833  *
2834  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2835  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2836  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2837  */
2838
2839 /* additional mixers to alc880_asus_mixer */
2840 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2841         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2842         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2843         { } /* end */
2844 };
2845
2846 /* TCL S700 */
2847 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2848         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2849         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2850         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2851         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2852         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2853         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2854         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2855         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2856         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2857         { } /* end */
2858 };
2859
2860 /* Uniwill */
2861 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2862         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2863         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2864         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2865         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2866         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2867         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2868         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2869         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2870         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2871         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2872         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2873         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2874         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2875         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2876         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2877         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2878         {
2879                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2880                 .name = "Channel Mode",
2881                 .info = alc_ch_mode_info,
2882                 .get = alc_ch_mode_get,
2883                 .put = alc_ch_mode_put,
2884         },
2885         { } /* end */
2886 };
2887
2888 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2889         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2890         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2891         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2892         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2893         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2894         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2895         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2896         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2897         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2898         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2899         { } /* end */
2900 };
2901
2902 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2903         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2904         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2905         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2906         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2907         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2908         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2909         { } /* end */
2910 };
2911
2912 /*
2913  * virtual master controls
2914  */
2915
2916 /*
2917  * slave controls for virtual master
2918  */
2919 static const char * const alc_slave_vols[] = {
2920         "Front Playback Volume",
2921         "Surround Playback Volume",
2922         "Center Playback Volume",
2923         "LFE Playback Volume",
2924         "Side Playback Volume",
2925         "Headphone Playback Volume",
2926         "Speaker Playback Volume",
2927         "Mono Playback Volume",
2928         "Line-Out Playback Volume",
2929         "PCM Playback Volume",
2930         NULL,
2931 };
2932
2933 static const char * const alc_slave_sws[] = {
2934         "Front Playback Switch",
2935         "Surround Playback Switch",
2936         "Center Playback Switch",
2937         "LFE Playback Switch",
2938         "Side Playback Switch",
2939         "Headphone Playback Switch",
2940         "Speaker Playback Switch",
2941         "Mono Playback Switch",
2942         "IEC958 Playback Switch",
2943         "Line-Out Playback Switch",
2944         "PCM Playback Switch",
2945         NULL,
2946 };
2947
2948 /*
2949  * build control elements
2950  */
2951
2952 #define NID_MAPPING             (-1)
2953
2954 #define SUBDEV_SPEAKER_         (0 << 6)
2955 #define SUBDEV_HP_              (1 << 6)
2956 #define SUBDEV_LINE_            (2 << 6)
2957 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2958 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2959 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2960
2961 static void alc_free_kctls(struct hda_codec *codec);
2962
2963 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2964 /* additional beep mixers; the actual parameters are overwritten at build */
2965 static struct snd_kcontrol_new alc_beep_mixer[] = {
2966         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2967         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2968         { } /* end */
2969 };
2970 #endif
2971
2972 static int alc_build_controls(struct hda_codec *codec)
2973 {
2974         struct alc_spec *spec = codec->spec;
2975         struct snd_kcontrol *kctl = NULL;
2976         struct snd_kcontrol_new *knew;
2977         int i, j, err;
2978         unsigned int u;
2979         hda_nid_t nid;
2980
2981         for (i = 0; i < spec->num_mixers; i++) {
2982                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2983                 if (err < 0)
2984                         return err;
2985         }
2986         if (spec->cap_mixer) {
2987                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2988                 if (err < 0)
2989                         return err;
2990         }
2991         if (spec->multiout.dig_out_nid) {
2992                 err = snd_hda_create_spdif_out_ctls(codec,
2993                                                     spec->multiout.dig_out_nid);
2994                 if (err < 0)
2995                         return err;
2996                 if (!spec->no_analog) {
2997                         err = snd_hda_create_spdif_share_sw(codec,
2998                                                             &spec->multiout);
2999                         if (err < 0)
3000                                 return err;
3001                         spec->multiout.share_spdif = 1;
3002                 }
3003         }
3004         if (spec->dig_in_nid) {
3005                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3006                 if (err < 0)
3007                         return err;
3008         }
3009
3010 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3011         /* create beep controls if needed */
3012         if (spec->beep_amp) {
3013                 struct snd_kcontrol_new *knew;
3014                 for (knew = alc_beep_mixer; knew->name; knew++) {
3015                         struct snd_kcontrol *kctl;
3016                         kctl = snd_ctl_new1(knew, codec);
3017                         if (!kctl)
3018                                 return -ENOMEM;
3019                         kctl->private_value = spec->beep_amp;
3020                         err = snd_hda_ctl_add(codec, 0, kctl);
3021                         if (err < 0)
3022                                 return err;
3023                 }
3024         }
3025 #endif
3026
3027         /* if we have no master control, let's create it */
3028         if (!spec->no_analog &&
3029             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3030                 unsigned int vmaster_tlv[4];
3031                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3032                                         HDA_OUTPUT, vmaster_tlv);
3033                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3034                                           vmaster_tlv, alc_slave_vols);
3035                 if (err < 0)
3036                         return err;
3037         }
3038         if (!spec->no_analog &&
3039             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3040                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
3041                                           NULL, alc_slave_sws);
3042                 if (err < 0)
3043                         return err;
3044         }
3045
3046         /* assign Capture Source enums to NID */
3047         if (spec->capsrc_nids || spec->adc_nids) {
3048                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
3049                 if (!kctl)
3050                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3051                 for (i = 0; kctl && i < kctl->count; i++) {
3052                         hda_nid_t *nids = spec->capsrc_nids;
3053                         if (!nids)
3054                                 nids = spec->adc_nids;
3055                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3056                         if (err < 0)
3057                                 return err;
3058                 }
3059         }
3060         if (spec->cap_mixer) {
3061                 const char *kname = kctl ? kctl->id.name : NULL;
3062                 for (knew = spec->cap_mixer; knew->name; knew++) {
3063                         if (kname && strcmp(knew->name, kname) == 0)
3064                                 continue;
3065                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3066                         for (i = 0; kctl && i < kctl->count; i++) {
3067                                 err = snd_hda_add_nid(codec, kctl, i,
3068                                                       spec->adc_nids[i]);
3069                                 if (err < 0)
3070                                         return err;
3071                         }
3072                 }
3073         }
3074
3075         /* other nid->control mapping */
3076         for (i = 0; i < spec->num_mixers; i++) {
3077                 for (knew = spec->mixers[i]; knew->name; knew++) {
3078                         if (knew->iface != NID_MAPPING)
3079                                 continue;
3080                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3081                         if (kctl == NULL)
3082                                 continue;
3083                         u = knew->subdevice;
3084                         for (j = 0; j < 4; j++, u >>= 8) {
3085                                 nid = u & 0x3f;
3086                                 if (nid == 0)
3087                                         continue;
3088                                 switch (u & 0xc0) {
3089                                 case SUBDEV_SPEAKER_:
3090                                         nid = spec->autocfg.speaker_pins[nid];
3091                                         break;
3092                                 case SUBDEV_LINE_:
3093                                         nid = spec->autocfg.line_out_pins[nid];
3094                                         break;
3095                                 case SUBDEV_HP_:
3096                                         nid = spec->autocfg.hp_pins[nid];
3097                                         break;
3098                                 default:
3099                                         continue;
3100                                 }
3101                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3102                                 if (err < 0)
3103                                         return err;
3104                         }
3105                         u = knew->private_value;
3106                         for (j = 0; j < 4; j++, u >>= 8) {
3107                                 nid = u & 0xff;
3108                                 if (nid == 0)
3109                                         continue;
3110                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3111                                 if (err < 0)
3112                                         return err;
3113                         }
3114                 }
3115         }
3116
3117         alc_free_kctls(codec); /* no longer needed */
3118
3119         return 0;
3120 }
3121
3122
3123 /*
3124  * initialize the codec volumes, etc
3125  */
3126
3127 /*
3128  * generic initialization of ADC, input mixers and output mixers
3129  */
3130 static struct hda_verb alc880_volume_init_verbs[] = {
3131         /*
3132          * Unmute ADC0-2 and set the default input to mic-in
3133          */
3134         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3135         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3136         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3137         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3138         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3139         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3140
3141         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3142          * mixer widget
3143          * Note: PASD motherboards uses the Line In 2 as the input for front
3144          * panel mic (mic 2)
3145          */
3146         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3147         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3148         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3149         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3150         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3151         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3152         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3153         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3154
3155         /*
3156          * Set up output mixers (0x0c - 0x0f)
3157          */
3158         /* set vol=0 to output mixers */
3159         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3160         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3161         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3162         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3163         /* set up input amps for analog loopback */
3164         /* Amp Indices: DAC = 0, mixer = 1 */
3165         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3166         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3167         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3168         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3169         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3170         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3171         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3172         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3173
3174         { }
3175 };
3176
3177 /*
3178  * 3-stack pin configuration:
3179  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3180  */
3181 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3182         /*
3183          * preset connection lists of input pins
3184          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3185          */
3186         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3187         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3188         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3189
3190         /*
3191          * Set pin mode and muting
3192          */
3193         /* set front pin widgets 0x14 for output */
3194         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3195         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3196         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3197         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3198         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3199         /* Mic2 (as headphone out) for HP output */
3200         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3201         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3202         /* Line In pin widget for input */
3203         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3204         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3205         /* Line2 (as front mic) pin widget for input and vref at 80% */
3206         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3207         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3208         /* CD pin widget for input */
3209         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3210
3211         { }
3212 };
3213
3214 /*
3215  * 5-stack pin configuration:
3216  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3217  * line-in/side = 0x1a, f-mic = 0x1b
3218  */
3219 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3220         /*
3221          * preset connection lists of input pins
3222          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3223          */
3224         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3225         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3226
3227         /*
3228          * Set pin mode and muting
3229          */
3230         /* set pin widgets 0x14-0x17 for output */
3231         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3232         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3233         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3234         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3235         /* unmute pins for output (no gain on this amp) */
3236         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3237         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3238         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3239         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3240
3241         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3242         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3243         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3244         /* Mic2 (as headphone out) for HP output */
3245         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3246         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3247         /* Line In pin widget for input */
3248         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3249         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3250         /* Line2 (as front mic) pin widget for input and vref at 80% */
3251         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3252         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3253         /* CD pin widget for input */
3254         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3255
3256         { }
3257 };
3258
3259 /*
3260  * W810 pin configuration:
3261  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3262  */
3263 static struct hda_verb alc880_pin_w810_init_verbs[] = {
3264         /* hphone/speaker input selector: front DAC */
3265         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3266
3267         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3268         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3269         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3270         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3271         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3272         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3273
3274         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3275         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3276
3277         { }
3278 };
3279
3280 /*
3281  * Z71V pin configuration:
3282  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3283  */
3284 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3285         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3286         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3287         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3288         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3289
3290         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3291         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3292         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3293         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3294
3295         { }
3296 };
3297
3298 /*
3299  * 6-stack pin configuration:
3300  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3301  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3302  */
3303 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3304         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3305
3306         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3307         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3308         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3309         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3310         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3311         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3312         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3313         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3314
3315         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3316         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3317         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3318         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3319         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3320         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3321         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3322         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3323         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3324
3325         { }
3326 };
3327
3328 /*
3329  * Uniwill pin configuration:
3330  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3331  * line = 0x1a
3332  */
3333 static struct hda_verb alc880_uniwill_init_verbs[] = {
3334         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3335
3336         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3337         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3338         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3339         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3340         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3341         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3342         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3343         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3344         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3346         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3347         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3348         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3349         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3350
3351         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3352         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3353         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3354         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3355         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3356         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3357         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3358         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3359         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3360
3361         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3362         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3363
3364         { }
3365 };
3366
3367 /*
3368 * Uniwill P53
3369 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3370  */
3371 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3372         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3373
3374         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3375         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3376         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3377         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3378         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3379         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3380         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3381         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3382         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3383         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3384         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3385         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3386
3387         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3388         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3389         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3390         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3391         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3392         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3393
3394         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3395         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3396
3397         { }
3398 };
3399
3400 static struct hda_verb alc880_beep_init_verbs[] = {
3401         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3402         { }
3403 };
3404
3405 /* auto-toggle front mic */
3406 static void alc88x_simple_mic_automute(struct hda_codec *codec)
3407 {
3408         unsigned int present;
3409         unsigned char bits;
3410
3411         present = snd_hda_jack_detect(codec, 0x18);
3412         bits = present ? HDA_AMP_MUTE : 0;
3413         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3414 }
3415
3416 static void alc880_uniwill_setup(struct hda_codec *codec)
3417 {
3418         struct alc_spec *spec = codec->spec;
3419
3420         spec->autocfg.hp_pins[0] = 0x14;
3421         spec->autocfg.speaker_pins[0] = 0x15;
3422         spec->autocfg.speaker_pins[0] = 0x16;
3423 }
3424
3425 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3426 {
3427         alc_automute_amp(codec);
3428         alc88x_simple_mic_automute(codec);
3429 }
3430
3431 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3432                                        unsigned int res)
3433 {
3434         /* Looks like the unsol event is incompatible with the standard
3435          * definition.  4bit tag is placed at 28 bit!
3436          */
3437         switch (res >> 28) {
3438         case ALC880_MIC_EVENT:
3439                 alc88x_simple_mic_automute(codec);
3440                 break;
3441         default:
3442                 alc_automute_amp_unsol_event(codec, res);
3443                 break;
3444         }
3445 }
3446
3447 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3448 {
3449         struct alc_spec *spec = codec->spec;
3450
3451         spec->autocfg.hp_pins[0] = 0x14;
3452         spec->autocfg.speaker_pins[0] = 0x15;
3453 }
3454
3455 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3456 {
3457         unsigned int present;
3458
3459         present = snd_hda_codec_read(codec, 0x21, 0,
3460                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3461         present &= HDA_AMP_VOLMASK;
3462         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3463                                  HDA_AMP_VOLMASK, present);
3464         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3465                                  HDA_AMP_VOLMASK, present);
3466 }
3467
3468 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3469                                            unsigned int res)
3470 {
3471         /* Looks like the unsol event is incompatible with the standard
3472          * definition.  4bit tag is placed at 28 bit!
3473          */
3474         if ((res >> 28) == ALC880_DCVOL_EVENT)
3475                 alc880_uniwill_p53_dcvol_automute(codec);
3476         else
3477                 alc_automute_amp_unsol_event(codec, res);
3478 }
3479
3480 /*
3481  * F1734 pin configuration:
3482  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3483  */
3484 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3485         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3486         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3487         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3488         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3489         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3490
3491         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3492         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3493         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3494         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3495
3496         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3497         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3498         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3499         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3500         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3501         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3502         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3503         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3504         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3505
3506         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3507         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3508
3509         { }
3510 };
3511
3512 /*
3513  * ASUS pin configuration:
3514  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3515  */
3516 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3517         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3518         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3519         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3520         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3521
3522         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3523         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3525         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3526         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3527         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3528         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3529         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3530
3531         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3532         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3533         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3534         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3535         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3536         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3537         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3538         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3539         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3540
3541         { }
3542 };
3543
3544 /* Enable GPIO mask and set output */
3545 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3546 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3547 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3548
3549 /* Clevo m520g init */
3550 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3551         /* headphone output */
3552         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3553         /* line-out */
3554         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3555         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3556         /* Line-in */
3557         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3558         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3559         /* CD */
3560         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3561         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3562         /* Mic1 (rear panel) */
3563         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3564         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3565         /* Mic2 (front panel) */
3566         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3567         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3568         /* headphone */
3569         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3570         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3571         /* change to EAPD mode */
3572         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3573         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3574
3575         { }
3576 };
3577
3578 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3579         /* change to EAPD mode */
3580         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3581         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3582
3583         /* Headphone output */
3584         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3585         /* Front output*/
3586         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3587         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3588
3589         /* Line In pin widget for input */
3590         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3591         /* CD pin widget for input */
3592         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3593         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3594         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3595
3596         /* change to EAPD mode */
3597         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3598         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3599
3600         { }
3601 };
3602
3603 /*
3604  * LG m1 express dual
3605  *
3606  * Pin assignment:
3607  *   Rear Line-In/Out (blue): 0x14
3608  *   Build-in Mic-In: 0x15
3609  *   Speaker-out: 0x17
3610  *   HP-Out (green): 0x1b
3611  *   Mic-In/Out (red): 0x19
3612  *   SPDIF-Out: 0x1e
3613  */
3614
3615 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3616 static hda_nid_t alc880_lg_dac_nids[3] = {
3617         0x05, 0x02, 0x03
3618 };
3619
3620 /* seems analog CD is not working */
3621 static struct hda_input_mux alc880_lg_capture_source = {
3622         .num_items = 3,
3623         .items = {
3624                 { "Mic", 0x1 },
3625                 { "Line", 0x5 },
3626                 { "Internal Mic", 0x6 },
3627         },
3628 };
3629
3630 /* 2,4,6 channel modes */
3631 static struct hda_verb alc880_lg_ch2_init[] = {
3632         /* set line-in and mic-in to input */
3633         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3634         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3635         { }
3636 };
3637
3638 static struct hda_verb alc880_lg_ch4_init[] = {
3639         /* set line-in to out and mic-in to input */
3640         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3641         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3642         { }
3643 };
3644
3645 static struct hda_verb alc880_lg_ch6_init[] = {
3646         /* set line-in and mic-in to output */
3647         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3648         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3649         { }
3650 };
3651
3652 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3653         { 2, alc880_lg_ch2_init },
3654         { 4, alc880_lg_ch4_init },
3655         { 6, alc880_lg_ch6_init },
3656 };
3657
3658 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3659         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3660         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3661         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3662         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3663         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3664         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3665         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3666         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3667         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3668         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3669         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3670         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3671         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3672         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3673         {
3674                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3675                 .name = "Channel Mode",
3676                 .info = alc_ch_mode_info,
3677                 .get = alc_ch_mode_get,
3678                 .put = alc_ch_mode_put,
3679         },
3680         { } /* end */
3681 };
3682
3683 static struct hda_verb alc880_lg_init_verbs[] = {
3684         /* set capture source to mic-in */
3685         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3686         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3687         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3688         /* mute all amp mixer inputs */
3689         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3690         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3691         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3692         /* line-in to input */
3693         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3694         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3695         /* built-in mic */
3696         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3697         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3698         /* speaker-out */
3699         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3700         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3701         /* mic-in to input */
3702         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3703         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3704         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3705         /* HP-out */
3706         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3707         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3708         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3709         /* jack sense */
3710         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3711         { }
3712 };
3713
3714 /* toggle speaker-output according to the hp-jack state */
3715 static void alc880_lg_setup(struct hda_codec *codec)
3716 {
3717         struct alc_spec *spec = codec->spec;
3718
3719         spec->autocfg.hp_pins[0] = 0x1b;
3720         spec->autocfg.speaker_pins[0] = 0x17;
3721 }
3722
3723 /*
3724  * LG LW20
3725  *
3726  * Pin assignment:
3727  *   Speaker-out: 0x14
3728  *   Mic-In: 0x18
3729  *   Built-in Mic-In: 0x19
3730  *   Line-In: 0x1b
3731  *   HP-Out: 0x1a
3732  *   SPDIF-Out: 0x1e
3733  */
3734
3735 static struct hda_input_mux alc880_lg_lw_capture_source = {
3736         .num_items = 3,
3737         .items = {
3738                 { "Mic", 0x0 },
3739                 { "Internal Mic", 0x1 },
3740                 { "Line In", 0x2 },
3741         },
3742 };
3743
3744 #define alc880_lg_lw_modes alc880_threestack_modes
3745
3746 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3747         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3748         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3749         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3750         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3751         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3752         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3753         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3754         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3755         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3756         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3757         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3758         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3759         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3760         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3761         {
3762                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3763                 .name = "Channel Mode",
3764                 .info = alc_ch_mode_info,
3765                 .get = alc_ch_mode_get,
3766                 .put = alc_ch_mode_put,
3767         },
3768         { } /* end */
3769 };
3770
3771 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3772         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3773         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3774         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3775
3776         /* set capture source to mic-in */
3777         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3778         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3779         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3780         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3781         /* speaker-out */
3782         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3783         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3784         /* HP-out */
3785         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3786         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3787         /* mic-in to input */
3788         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3789         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3790         /* built-in mic */
3791         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3792         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3793         /* jack sense */
3794         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3795         { }
3796 };
3797
3798 /* toggle speaker-output according to the hp-jack state */
3799 static void alc880_lg_lw_setup(struct hda_codec *codec)
3800 {
3801         struct alc_spec *spec = codec->spec;
3802
3803         spec->autocfg.hp_pins[0] = 0x1b;
3804         spec->autocfg.speaker_pins[0] = 0x14;
3805 }
3806
3807 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3808         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3809         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3811         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3812         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3813         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3814         { } /* end */
3815 };
3816
3817 static struct hda_input_mux alc880_medion_rim_capture_source = {
3818         .num_items = 2,
3819         .items = {
3820                 { "Mic", 0x0 },
3821                 { "Internal Mic", 0x1 },
3822         },
3823 };
3824
3825 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3826         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3827
3828         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3829         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3830
3831         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3832         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3833         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3834         /* Mic2 (as headphone out) for HP output */
3835         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3836         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3837         /* Internal Speaker */
3838         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3839         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3840
3841         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3842         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3843
3844         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3845         { }
3846 };
3847
3848 /* toggle speaker-output according to the hp-jack state */
3849 static void alc880_medion_rim_automute(struct hda_codec *codec)
3850 {
3851         struct alc_spec *spec = codec->spec;
3852         alc_automute_amp(codec);
3853         /* toggle EAPD */
3854         if (spec->jack_present)
3855                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3856         else
3857                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3858 }
3859
3860 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3861                                           unsigned int res)
3862 {
3863         /* Looks like the unsol event is incompatible with the standard
3864          * definition.  4bit tag is placed at 28 bit!
3865          */
3866         if ((res >> 28) == ALC880_HP_EVENT)
3867                 alc880_medion_rim_automute(codec);
3868 }
3869
3870 static void alc880_medion_rim_setup(struct hda_codec *codec)
3871 {
3872         struct alc_spec *spec = codec->spec;
3873
3874         spec->autocfg.hp_pins[0] = 0x14;
3875         spec->autocfg.speaker_pins[0] = 0x1b;
3876 }
3877
3878 #ifdef CONFIG_SND_HDA_POWER_SAVE
3879 static struct hda_amp_list alc880_loopbacks[] = {
3880         { 0x0b, HDA_INPUT, 0 },
3881         { 0x0b, HDA_INPUT, 1 },
3882         { 0x0b, HDA_INPUT, 2 },
3883         { 0x0b, HDA_INPUT, 3 },
3884         { 0x0b, HDA_INPUT, 4 },
3885         { } /* end */
3886 };
3887
3888 static struct hda_amp_list alc880_lg_loopbacks[] = {
3889         { 0x0b, HDA_INPUT, 1 },
3890         { 0x0b, HDA_INPUT, 6 },
3891         { 0x0b, HDA_INPUT, 7 },
3892         { } /* end */
3893 };
3894 #endif
3895
3896 /*
3897  * Common callbacks
3898  */
3899
3900 static int alc_init(struct hda_codec *codec)
3901 {
3902         struct alc_spec *spec = codec->spec;
3903         unsigned int i;
3904
3905         alc_fix_pll(codec);
3906         alc_auto_init_amp(codec, spec->init_amp);
3907
3908         for (i = 0; i < spec->num_init_verbs; i++)
3909                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3910
3911         if (spec->init_hook)
3912                 spec->init_hook(codec);
3913
3914         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
3915
3916         hda_call_check_power_status(codec, 0x01);
3917         return 0;
3918 }
3919
3920 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3921 {
3922         struct alc_spec *spec = codec->spec;
3923
3924         if (spec->unsol_event)
3925                 spec->unsol_event(codec, res);
3926 }
3927
3928 #ifdef CONFIG_SND_HDA_POWER_SAVE
3929 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3930 {
3931         struct alc_spec *spec = codec->spec;
3932         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3933 }
3934 #endif
3935
3936 /*
3937  * Analog playback callbacks
3938  */
3939 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3940                                     struct hda_codec *codec,
3941                                     struct snd_pcm_substream *substream)
3942 {
3943         struct alc_spec *spec = codec->spec;
3944         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3945                                              hinfo);
3946 }
3947
3948 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3949                                        struct hda_codec *codec,
3950                                        unsigned int stream_tag,
3951                                        unsigned int format,
3952                                        struct snd_pcm_substream *substream)
3953 {
3954         struct alc_spec *spec = codec->spec;
3955         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3956                                                 stream_tag, format, substream);
3957 }
3958
3959 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3960                                        struct hda_codec *codec,
3961                                        struct snd_pcm_substream *substream)
3962 {
3963         struct alc_spec *spec = codec->spec;
3964         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3965 }
3966
3967 /*
3968  * Digital out
3969  */
3970 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3971                                         struct hda_codec *codec,
3972                                         struct snd_pcm_substream *substream)
3973 {
3974         struct alc_spec *spec = codec->spec;
3975         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3976 }
3977
3978 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3979                                            struct hda_codec *codec,
3980                                            unsigned int stream_tag,
3981                                            unsigned int format,
3982                                            struct snd_pcm_substream *substream)
3983 {
3984         struct alc_spec *spec = codec->spec;
3985         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3986                                              stream_tag, format, substream);
3987 }
3988
3989 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3990                                            struct hda_codec *codec,
3991                                            struct snd_pcm_substream *substream)
3992 {
3993         struct alc_spec *spec = codec->spec;
3994         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3995 }
3996
3997 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3998                                          struct hda_codec *codec,
3999                                          struct snd_pcm_substream *substream)
4000 {
4001         struct alc_spec *spec = codec->spec;
4002         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4003 }
4004
4005 /*
4006  * Analog capture
4007  */
4008 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4009                                       struct hda_codec *codec,
4010                                       unsigned int stream_tag,
4011                                       unsigned int format,
4012                                       struct snd_pcm_substream *substream)
4013 {
4014         struct alc_spec *spec = codec->spec;
4015
4016         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4017                                    stream_tag, 0, format);
4018         return 0;
4019 }
4020
4021 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4022                                       struct hda_codec *codec,
4023                                       struct snd_pcm_substream *substream)
4024 {
4025         struct alc_spec *spec = codec->spec;
4026
4027         snd_hda_codec_cleanup_stream(codec,
4028                                      spec->adc_nids[substream->number + 1]);
4029         return 0;
4030 }
4031
4032 /* analog capture with dynamic dual-adc changes */
4033 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4034                                        struct hda_codec *codec,
4035                                        unsigned int stream_tag,
4036                                        unsigned int format,
4037                                        struct snd_pcm_substream *substream)
4038 {
4039         struct alc_spec *spec = codec->spec;
4040         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
4041         spec->cur_adc_stream_tag = stream_tag;
4042         spec->cur_adc_format = format;
4043         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4044         return 0;
4045 }
4046
4047 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4048                                        struct hda_codec *codec,
4049                                        struct snd_pcm_substream *substream)
4050 {
4051         struct alc_spec *spec = codec->spec;
4052         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4053         spec->cur_adc = 0;
4054         return 0;
4055 }
4056
4057 static struct hda_pcm_stream dualmic_pcm_analog_capture = {
4058         .substreams = 1,
4059         .channels_min = 2,
4060         .channels_max = 2,
4061         .nid = 0, /* fill later */
4062         .ops = {
4063                 .prepare = dualmic_capture_pcm_prepare,
4064                 .cleanup = dualmic_capture_pcm_cleanup
4065         },
4066 };
4067
4068 /*
4069  */
4070 static struct hda_pcm_stream alc880_pcm_analog_playback = {
4071         .substreams = 1,
4072         .channels_min = 2,
4073         .channels_max = 8,
4074         /* NID is set in alc_build_pcms */
4075         .ops = {
4076                 .open = alc880_playback_pcm_open,
4077                 .prepare = alc880_playback_pcm_prepare,
4078                 .cleanup = alc880_playback_pcm_cleanup
4079         },
4080 };
4081
4082 static struct hda_pcm_stream alc880_pcm_analog_capture = {
4083         .substreams = 1,
4084         .channels_min = 2,
4085         .channels_max = 2,
4086         /* NID is set in alc_build_pcms */
4087 };
4088
4089 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4090         .substreams = 1,
4091         .channels_min = 2,
4092         .channels_max = 2,
4093         /* NID is set in alc_build_pcms */
4094 };
4095
4096 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4097         .substreams = 2, /* can be overridden */
4098         .channels_min = 2,
4099         .channels_max = 2,
4100         /* NID is set in alc_build_pcms */
4101         .ops = {
4102                 .prepare = alc880_alt_capture_pcm_prepare,
4103                 .cleanup = alc880_alt_capture_pcm_cleanup
4104         },
4105 };
4106
4107 static struct hda_pcm_stream alc880_pcm_digital_playback = {
4108         .substreams = 1,
4109         .channels_min = 2,
4110         .channels_max = 2,
4111         /* NID is set in alc_build_pcms */
4112         .ops = {
4113                 .open = alc880_dig_playback_pcm_open,
4114                 .close = alc880_dig_playback_pcm_close,
4115                 .prepare = alc880_dig_playback_pcm_prepare,
4116                 .cleanup = alc880_dig_playback_pcm_cleanup
4117         },
4118 };
4119
4120 static struct hda_pcm_stream alc880_pcm_digital_capture = {
4121         .substreams = 1,
4122         .channels_min = 2,
4123         .channels_max = 2,
4124         /* NID is set in alc_build_pcms */
4125 };
4126
4127 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4128 static struct hda_pcm_stream alc_pcm_null_stream = {
4129         .substreams = 0,
4130         .channels_min = 0,
4131         .channels_max = 0,
4132 };
4133
4134 static int alc_build_pcms(struct hda_codec *codec)
4135 {
4136         struct alc_spec *spec = codec->spec;
4137         struct hda_pcm *info = spec->pcm_rec;
4138         int i;
4139
4140         codec->num_pcms = 1;
4141         codec->pcm_info = info;
4142
4143         if (spec->no_analog)
4144                 goto skip_analog;
4145
4146         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4147                  "%s Analog", codec->chip_name);
4148         info->name = spec->stream_name_analog;
4149
4150         if (spec->stream_analog_playback) {
4151                 if (snd_BUG_ON(!spec->multiout.dac_nids))
4152                         return -EINVAL;
4153                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4154                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4155         }
4156         if (spec->stream_analog_capture) {
4157                 if (snd_BUG_ON(!spec->adc_nids))
4158                         return -EINVAL;
4159                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4160                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4161         }
4162
4163         if (spec->channel_mode) {
4164                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4165                 for (i = 0; i < spec->num_channel_mode; i++) {
4166                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4167                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4168                         }
4169                 }
4170         }
4171
4172  skip_analog:
4173         /* SPDIF for stream index #1 */
4174         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4175                 snprintf(spec->stream_name_digital,
4176                          sizeof(spec->stream_name_digital),
4177                          "%s Digital", codec->chip_name);
4178                 codec->num_pcms = 2;
4179                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4180                 info = spec->pcm_rec + 1;
4181                 info->name = spec->stream_name_digital;
4182                 if (spec->dig_out_type)
4183                         info->pcm_type = spec->dig_out_type;
4184                 else
4185                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4186                 if (spec->multiout.dig_out_nid &&
4187                     spec->stream_digital_playback) {
4188                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4189                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4190                 }
4191                 if (spec->dig_in_nid &&
4192                     spec->stream_digital_capture) {
4193                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4194                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4195                 }
4196                 /* FIXME: do we need this for all Realtek codec models? */
4197                 codec->spdif_status_reset = 1;
4198         }
4199
4200         if (spec->no_analog)
4201                 return 0;
4202
4203         /* If the use of more than one ADC is requested for the current
4204          * model, configure a second analog capture-only PCM.
4205          */
4206         /* Additional Analaog capture for index #2 */
4207         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4208             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4209                 codec->num_pcms = 3;
4210                 info = spec->pcm_rec + 2;
4211                 info->name = spec->stream_name_analog;
4212                 if (spec->alt_dac_nid) {
4213                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4214                                 *spec->stream_analog_alt_playback;
4215                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4216                                 spec->alt_dac_nid;
4217                 } else {
4218                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4219                                 alc_pcm_null_stream;
4220                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4221                 }
4222                 if (spec->num_adc_nids > 1) {
4223                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4224                                 *spec->stream_analog_alt_capture;
4225                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4226                                 spec->adc_nids[1];
4227                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4228                                 spec->num_adc_nids - 1;
4229                 } else {
4230                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4231                                 alc_pcm_null_stream;
4232                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4233                 }
4234         }
4235
4236         return 0;
4237 }
4238
4239 static inline void alc_shutup(struct hda_codec *codec)
4240 {
4241         snd_hda_shutup_pins(codec);
4242 }
4243
4244 static void alc_free_kctls(struct hda_codec *codec)
4245 {
4246         struct alc_spec *spec = codec->spec;
4247
4248         if (spec->kctls.list) {
4249                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4250                 int i;
4251                 for (i = 0; i < spec->kctls.used; i++)
4252                         kfree(kctl[i].name);
4253         }
4254         snd_array_free(&spec->kctls);
4255 }
4256
4257 static void alc_free(struct hda_codec *codec)
4258 {
4259         struct alc_spec *spec = codec->spec;
4260
4261         if (!spec)
4262                 return;
4263
4264         alc_shutup(codec);
4265         alc_free_kctls(codec);
4266         kfree(spec);
4267         snd_hda_detach_beep_device(codec);
4268 }
4269
4270 #ifdef CONFIG_SND_HDA_POWER_SAVE
4271 static void alc_power_eapd(struct hda_codec *codec)
4272 {
4273         /* We currently only handle front, HP */
4274         switch (codec->vendor_id) {
4275         case 0x10ec0260:
4276                 set_eapd(codec, 0x0f, 0);
4277                 set_eapd(codec, 0x10, 0);
4278                 break;
4279         case 0x10ec0262:
4280         case 0x10ec0267:
4281         case 0x10ec0268:
4282         case 0x10ec0269:
4283         case 0x10ec0270:
4284         case 0x10ec0272:
4285         case 0x10ec0660:
4286         case 0x10ec0662:
4287         case 0x10ec0663:
4288         case 0x10ec0862:
4289         case 0x10ec0889:
4290                 set_eapd(codec, 0x14, 0);
4291                 set_eapd(codec, 0x15, 0);
4292                 break;
4293         }
4294 }
4295
4296 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4297 {
4298         struct alc_spec *spec = codec->spec;
4299         alc_shutup(codec);
4300         if (spec && spec->power_hook)
4301                 spec->power_hook(codec);
4302         return 0;
4303 }
4304 #endif
4305
4306 #ifdef SND_HDA_NEEDS_RESUME
4307 static int alc_resume(struct hda_codec *codec)
4308 {
4309         codec->patch_ops.init(codec);
4310         snd_hda_codec_resume_amp(codec);
4311         snd_hda_codec_resume_cache(codec);
4312         hda_call_check_power_status(codec, 0x01);
4313         return 0;
4314 }
4315 #endif
4316
4317 /*
4318  */
4319 static struct hda_codec_ops alc_patch_ops = {
4320         .build_controls = alc_build_controls,
4321         .build_pcms = alc_build_pcms,
4322         .init = alc_init,
4323         .free = alc_free,
4324         .unsol_event = alc_unsol_event,
4325 #ifdef SND_HDA_NEEDS_RESUME
4326         .resume = alc_resume,
4327 #endif
4328 #ifdef CONFIG_SND_HDA_POWER_SAVE
4329         .suspend = alc_suspend,
4330         .check_power_status = alc_check_power_status,
4331 #endif
4332         .reboot_notify = alc_shutup,
4333 };
4334
4335 /* replace the codec chip_name with the given string */
4336 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4337 {
4338         kfree(codec->chip_name);
4339         codec->chip_name = kstrdup(name, GFP_KERNEL);
4340         if (!codec->chip_name) {
4341                 alc_free(codec);
4342                 return -ENOMEM;
4343         }
4344         return 0;
4345 }
4346
4347 /*
4348  * Test configuration for debugging
4349  *
4350  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4351  * enum controls.
4352  */
4353 #ifdef CONFIG_SND_DEBUG
4354 static hda_nid_t alc880_test_dac_nids[4] = {
4355         0x02, 0x03, 0x04, 0x05
4356 };
4357
4358 static struct hda_input_mux alc880_test_capture_source = {
4359         .num_items = 7,
4360         .items = {
4361                 { "In-1", 0x0 },
4362                 { "In-2", 0x1 },
4363                 { "In-3", 0x2 },
4364                 { "In-4", 0x3 },
4365                 { "CD", 0x4 },
4366                 { "Front", 0x5 },
4367                 { "Surround", 0x6 },
4368         },
4369 };
4370
4371 static struct hda_channel_mode alc880_test_modes[4] = {
4372         { 2, NULL },
4373         { 4, NULL },
4374         { 6, NULL },
4375         { 8, NULL },
4376 };
4377
4378 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4379                                  struct snd_ctl_elem_info *uinfo)
4380 {
4381         static char *texts[] = {
4382                 "N/A", "Line Out", "HP Out",
4383                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4384         };
4385         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4386         uinfo->count = 1;
4387         uinfo->value.enumerated.items = 8;
4388         if (uinfo->value.enumerated.item >= 8)
4389                 uinfo->value.enumerated.item = 7;
4390         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4391         return 0;
4392 }
4393
4394 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4395                                 struct snd_ctl_elem_value *ucontrol)
4396 {
4397         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4398         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4399         unsigned int pin_ctl, item = 0;
4400
4401         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4402                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4403         if (pin_ctl & AC_PINCTL_OUT_EN) {
4404                 if (pin_ctl & AC_PINCTL_HP_EN)
4405                         item = 2;
4406                 else
4407                         item = 1;
4408         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4409                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4410                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4411                 case AC_PINCTL_VREF_50:  item = 4; break;
4412                 case AC_PINCTL_VREF_GRD: item = 5; break;
4413                 case AC_PINCTL_VREF_80:  item = 6; break;
4414                 case AC_PINCTL_VREF_100: item = 7; break;
4415                 }
4416         }
4417         ucontrol->value.enumerated.item[0] = item;
4418         return 0;
4419 }
4420
4421 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4422                                 struct snd_ctl_elem_value *ucontrol)
4423 {
4424         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4425         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4426         static unsigned int ctls[] = {
4427                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4428                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4429                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4430                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4431                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4432                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4433         };
4434         unsigned int old_ctl, new_ctl;
4435
4436         old_ctl = snd_hda_codec_read(codec, nid, 0,
4437                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4438         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4439         if (old_ctl != new_ctl) {
4440                 int val;
4441                 snd_hda_codec_write_cache(codec, nid, 0,
4442                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4443                                           new_ctl);
4444                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4445                         HDA_AMP_MUTE : 0;
4446                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4447                                          HDA_AMP_MUTE, val);
4448                 return 1;
4449         }
4450         return 0;
4451 }
4452
4453 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4454                                  struct snd_ctl_elem_info *uinfo)
4455 {
4456         static char *texts[] = {
4457                 "Front", "Surround", "CLFE", "Side"
4458         };
4459         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4460         uinfo->count = 1;
4461         uinfo->value.enumerated.items = 4;
4462         if (uinfo->value.enumerated.item >= 4)
4463                 uinfo->value.enumerated.item = 3;
4464         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4465         return 0;
4466 }
4467
4468 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4469                                 struct snd_ctl_elem_value *ucontrol)
4470 {
4471         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4472         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4473         unsigned int sel;
4474
4475         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4476         ucontrol->value.enumerated.item[0] = sel & 3;
4477         return 0;
4478 }
4479
4480 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4481                                 struct snd_ctl_elem_value *ucontrol)
4482 {
4483         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4484         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4485         unsigned int sel;
4486
4487         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4488         if (ucontrol->value.enumerated.item[0] != sel) {
4489                 sel = ucontrol->value.enumerated.item[0] & 3;
4490                 snd_hda_codec_write_cache(codec, nid, 0,
4491                                           AC_VERB_SET_CONNECT_SEL, sel);
4492                 return 1;
4493         }
4494         return 0;
4495 }
4496
4497 #define PIN_CTL_TEST(xname,nid) {                       \
4498                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4499                         .name = xname,                 \
4500                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4501                         .info = alc_test_pin_ctl_info, \
4502                         .get = alc_test_pin_ctl_get,   \
4503                         .put = alc_test_pin_ctl_put,   \
4504                         .private_value = nid           \
4505                         }
4506
4507 #define PIN_SRC_TEST(xname,nid) {                       \
4508                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4509                         .name = xname,                 \
4510                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4511                         .info = alc_test_pin_src_info, \
4512                         .get = alc_test_pin_src_get,   \
4513                         .put = alc_test_pin_src_put,   \
4514                         .private_value = nid           \
4515                         }
4516
4517 static struct snd_kcontrol_new alc880_test_mixer[] = {
4518         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4519         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4520         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4521         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4522         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4523         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4524         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4525         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4526         PIN_CTL_TEST("Front Pin Mode", 0x14),
4527         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4528         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4529         PIN_CTL_TEST("Side Pin Mode", 0x17),
4530         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4531         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4532         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4533         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4534         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4535         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4536         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4537         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4538         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4539         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4540         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4541         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4542         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4543         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4544         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4545         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4546         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4547         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4548         {
4549                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4550                 .name = "Channel Mode",
4551                 .info = alc_ch_mode_info,
4552                 .get = alc_ch_mode_get,
4553                 .put = alc_ch_mode_put,
4554         },
4555         { } /* end */
4556 };
4557
4558 static struct hda_verb alc880_test_init_verbs[] = {
4559         /* Unmute inputs of 0x0c - 0x0f */
4560         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4561         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4562         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4563         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4564         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4565         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4566         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4567         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4568         /* Vol output for 0x0c-0x0f */
4569         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4570         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4571         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4572         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4573         /* Set output pins 0x14-0x17 */
4574         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4575         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4576         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4577         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4578         /* Unmute output pins 0x14-0x17 */
4579         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4580         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4581         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4582         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4583         /* Set input pins 0x18-0x1c */
4584         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4585         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4586         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4587         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4588         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4589         /* Mute input pins 0x18-0x1b */
4590         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4591         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4592         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4593         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4594         /* ADC set up */
4595         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4596         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4597         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4598         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4599         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4600         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4601         /* Analog input/passthru */
4602         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4603         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4604         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4605         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4606         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4607         { }
4608 };
4609 #endif
4610
4611 /*
4612  */
4613
4614 static const char * const alc880_models[ALC880_MODEL_LAST] = {
4615         [ALC880_3ST]            = "3stack",
4616         [ALC880_TCL_S700]       = "tcl",
4617         [ALC880_3ST_DIG]        = "3stack-digout",
4618         [ALC880_CLEVO]          = "clevo",
4619         [ALC880_5ST]            = "5stack",
4620         [ALC880_5ST_DIG]        = "5stack-digout",
4621         [ALC880_W810]           = "w810",
4622         [ALC880_Z71V]           = "z71v",
4623         [ALC880_6ST]            = "6stack",
4624         [ALC880_6ST_DIG]        = "6stack-digout",
4625         [ALC880_ASUS]           = "asus",
4626         [ALC880_ASUS_W1V]       = "asus-w1v",
4627         [ALC880_ASUS_DIG]       = "asus-dig",
4628         [ALC880_ASUS_DIG2]      = "asus-dig2",
4629         [ALC880_UNIWILL_DIG]    = "uniwill",
4630         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4631         [ALC880_FUJITSU]        = "fujitsu",
4632         [ALC880_F1734]          = "F1734",
4633         [ALC880_LG]             = "lg",
4634         [ALC880_LG_LW]          = "lg-lw",
4635         [ALC880_MEDION_RIM]     = "medion",
4636 #ifdef CONFIG_SND_DEBUG
4637         [ALC880_TEST]           = "test",
4638 #endif
4639         [ALC880_AUTO]           = "auto",
4640 };
4641
4642 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4643         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4644         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4645         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4646         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4647         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4648         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4649         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4650         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4651         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4652         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4653         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4654         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4655         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4656         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4657         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4658         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4659         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4660         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4661         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4662         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4663         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4664         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4665         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4666         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4667         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4668         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4669         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4670         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4671         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4672         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4673         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4674         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4675         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4676         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4677         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4678         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4679         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4680         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4681         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4682         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4683         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4684         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4685         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4686         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4687         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4688         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4689         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4690         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4691         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4692         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4693         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4694         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4695         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4696         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4697         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4698         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4699         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4700         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4701         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4702         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4703         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4704         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4705         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4706         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4707         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4708         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4709         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4710         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4711         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4712         /* default Intel */
4713         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4714         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4715         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4716         {}
4717 };
4718
4719 /*
4720  * ALC880 codec presets
4721  */
4722 static struct alc_config_preset alc880_presets[] = {
4723         [ALC880_3ST] = {
4724                 .mixers = { alc880_three_stack_mixer },
4725                 .init_verbs = { alc880_volume_init_verbs,
4726                                 alc880_pin_3stack_init_verbs },
4727                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4728                 .dac_nids = alc880_dac_nids,
4729                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4730                 .channel_mode = alc880_threestack_modes,
4731                 .need_dac_fix = 1,
4732                 .input_mux = &alc880_capture_source,
4733         },
4734         [ALC880_3ST_DIG] = {
4735                 .mixers = { alc880_three_stack_mixer },
4736                 .init_verbs = { alc880_volume_init_verbs,
4737                                 alc880_pin_3stack_init_verbs },
4738                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4739                 .dac_nids = alc880_dac_nids,
4740                 .dig_out_nid = ALC880_DIGOUT_NID,
4741                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4742                 .channel_mode = alc880_threestack_modes,
4743                 .need_dac_fix = 1,
4744                 .input_mux = &alc880_capture_source,
4745         },
4746         [ALC880_TCL_S700] = {
4747                 .mixers = { alc880_tcl_s700_mixer },
4748                 .init_verbs = { alc880_volume_init_verbs,
4749                                 alc880_pin_tcl_S700_init_verbs,
4750                                 alc880_gpio2_init_verbs },
4751                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4752                 .dac_nids = alc880_dac_nids,
4753                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4754                 .num_adc_nids = 1, /* single ADC */
4755                 .hp_nid = 0x03,
4756                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4757                 .channel_mode = alc880_2_jack_modes,
4758                 .input_mux = &alc880_capture_source,
4759         },
4760         [ALC880_5ST] = {
4761                 .mixers = { alc880_three_stack_mixer,
4762                             alc880_five_stack_mixer},
4763                 .init_verbs = { alc880_volume_init_verbs,
4764                                 alc880_pin_5stack_init_verbs },
4765                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4766                 .dac_nids = alc880_dac_nids,
4767                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4768                 .channel_mode = alc880_fivestack_modes,
4769                 .input_mux = &alc880_capture_source,
4770         },
4771         [ALC880_5ST_DIG] = {
4772                 .mixers = { alc880_three_stack_mixer,
4773                             alc880_five_stack_mixer },
4774                 .init_verbs = { alc880_volume_init_verbs,
4775                                 alc880_pin_5stack_init_verbs },
4776                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4777                 .dac_nids = alc880_dac_nids,
4778                 .dig_out_nid = ALC880_DIGOUT_NID,
4779                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4780                 .channel_mode = alc880_fivestack_modes,
4781                 .input_mux = &alc880_capture_source,
4782         },
4783         [ALC880_6ST] = {
4784                 .mixers = { alc880_six_stack_mixer },
4785                 .init_verbs = { alc880_volume_init_verbs,
4786                                 alc880_pin_6stack_init_verbs },
4787                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4788                 .dac_nids = alc880_6st_dac_nids,
4789                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4790                 .channel_mode = alc880_sixstack_modes,
4791                 .input_mux = &alc880_6stack_capture_source,
4792         },
4793         [ALC880_6ST_DIG] = {
4794                 .mixers = { alc880_six_stack_mixer },
4795                 .init_verbs = { alc880_volume_init_verbs,
4796                                 alc880_pin_6stack_init_verbs },
4797                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4798                 .dac_nids = alc880_6st_dac_nids,
4799                 .dig_out_nid = ALC880_DIGOUT_NID,
4800                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4801                 .channel_mode = alc880_sixstack_modes,
4802                 .input_mux = &alc880_6stack_capture_source,
4803         },
4804         [ALC880_W810] = {
4805                 .mixers = { alc880_w810_base_mixer },
4806                 .init_verbs = { alc880_volume_init_verbs,
4807                                 alc880_pin_w810_init_verbs,
4808                                 alc880_gpio2_init_verbs },
4809                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4810                 .dac_nids = alc880_w810_dac_nids,
4811                 .dig_out_nid = ALC880_DIGOUT_NID,
4812                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4813                 .channel_mode = alc880_w810_modes,
4814                 .input_mux = &alc880_capture_source,
4815         },
4816         [ALC880_Z71V] = {
4817                 .mixers = { alc880_z71v_mixer },
4818                 .init_verbs = { alc880_volume_init_verbs,
4819                                 alc880_pin_z71v_init_verbs },
4820                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4821                 .dac_nids = alc880_z71v_dac_nids,
4822                 .dig_out_nid = ALC880_DIGOUT_NID,
4823                 .hp_nid = 0x03,
4824                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4825                 .channel_mode = alc880_2_jack_modes,
4826                 .input_mux = &alc880_capture_source,
4827         },
4828         [ALC880_F1734] = {
4829                 .mixers = { alc880_f1734_mixer },
4830                 .init_verbs = { alc880_volume_init_verbs,
4831                                 alc880_pin_f1734_init_verbs },
4832                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4833                 .dac_nids = alc880_f1734_dac_nids,
4834                 .hp_nid = 0x02,
4835                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4836                 .channel_mode = alc880_2_jack_modes,
4837                 .input_mux = &alc880_f1734_capture_source,
4838                 .unsol_event = alc880_uniwill_p53_unsol_event,
4839                 .setup = alc880_uniwill_p53_setup,
4840                 .init_hook = alc_automute_amp,
4841         },
4842         [ALC880_ASUS] = {
4843                 .mixers = { alc880_asus_mixer },
4844                 .init_verbs = { alc880_volume_init_verbs,
4845                                 alc880_pin_asus_init_verbs,
4846                                 alc880_gpio1_init_verbs },
4847                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4848                 .dac_nids = alc880_asus_dac_nids,
4849                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4850                 .channel_mode = alc880_asus_modes,
4851                 .need_dac_fix = 1,
4852                 .input_mux = &alc880_capture_source,
4853         },
4854         [ALC880_ASUS_DIG] = {
4855                 .mixers = { alc880_asus_mixer },
4856                 .init_verbs = { alc880_volume_init_verbs,
4857                                 alc880_pin_asus_init_verbs,
4858                                 alc880_gpio1_init_verbs },
4859                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4860                 .dac_nids = alc880_asus_dac_nids,
4861                 .dig_out_nid = ALC880_DIGOUT_NID,
4862                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4863                 .channel_mode = alc880_asus_modes,
4864                 .need_dac_fix = 1,
4865                 .input_mux = &alc880_capture_source,
4866         },
4867         [ALC880_ASUS_DIG2] = {
4868                 .mixers = { alc880_asus_mixer },
4869                 .init_verbs = { alc880_volume_init_verbs,
4870                                 alc880_pin_asus_init_verbs,
4871                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4872                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4873                 .dac_nids = alc880_asus_dac_nids,
4874                 .dig_out_nid = ALC880_DIGOUT_NID,
4875                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4876                 .channel_mode = alc880_asus_modes,
4877                 .need_dac_fix = 1,
4878                 .input_mux = &alc880_capture_source,
4879         },
4880         [ALC880_ASUS_W1V] = {
4881                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4882                 .init_verbs = { alc880_volume_init_verbs,
4883                                 alc880_pin_asus_init_verbs,
4884                                 alc880_gpio1_init_verbs },
4885                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4886                 .dac_nids = alc880_asus_dac_nids,
4887                 .dig_out_nid = ALC880_DIGOUT_NID,
4888                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4889                 .channel_mode = alc880_asus_modes,
4890                 .need_dac_fix = 1,
4891                 .input_mux = &alc880_capture_source,
4892         },
4893         [ALC880_UNIWILL_DIG] = {
4894                 .mixers = { alc880_asus_mixer },
4895                 .init_verbs = { alc880_volume_init_verbs,
4896                                 alc880_pin_asus_init_verbs },
4897                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4898                 .dac_nids = alc880_asus_dac_nids,
4899                 .dig_out_nid = ALC880_DIGOUT_NID,
4900                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4901                 .channel_mode = alc880_asus_modes,
4902                 .need_dac_fix = 1,
4903                 .input_mux = &alc880_capture_source,
4904         },
4905         [ALC880_UNIWILL] = {
4906                 .mixers = { alc880_uniwill_mixer },
4907                 .init_verbs = { alc880_volume_init_verbs,
4908                                 alc880_uniwill_init_verbs },
4909                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4910                 .dac_nids = alc880_asus_dac_nids,
4911                 .dig_out_nid = ALC880_DIGOUT_NID,
4912                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4913                 .channel_mode = alc880_threestack_modes,
4914                 .need_dac_fix = 1,
4915                 .input_mux = &alc880_capture_source,
4916                 .unsol_event = alc880_uniwill_unsol_event,
4917                 .setup = alc880_uniwill_setup,
4918                 .init_hook = alc880_uniwill_init_hook,
4919         },
4920         [ALC880_UNIWILL_P53] = {
4921                 .mixers = { alc880_uniwill_p53_mixer },
4922                 .init_verbs = { alc880_volume_init_verbs,
4923                                 alc880_uniwill_p53_init_verbs },
4924                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4925                 .dac_nids = alc880_asus_dac_nids,
4926                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4927                 .channel_mode = alc880_threestack_modes,
4928                 .input_mux = &alc880_capture_source,
4929                 .unsol_event = alc880_uniwill_p53_unsol_event,
4930                 .setup = alc880_uniwill_p53_setup,
4931                 .init_hook = alc_automute_amp,
4932         },
4933         [ALC880_FUJITSU] = {
4934                 .mixers = { alc880_fujitsu_mixer },
4935                 .init_verbs = { alc880_volume_init_verbs,
4936                                 alc880_uniwill_p53_init_verbs,
4937                                 alc880_beep_init_verbs },
4938                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4939                 .dac_nids = alc880_dac_nids,
4940                 .dig_out_nid = ALC880_DIGOUT_NID,
4941                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4942                 .channel_mode = alc880_2_jack_modes,
4943                 .input_mux = &alc880_capture_source,
4944                 .unsol_event = alc880_uniwill_p53_unsol_event,
4945                 .setup = alc880_uniwill_p53_setup,
4946                 .init_hook = alc_automute_amp,
4947         },
4948         [ALC880_CLEVO] = {
4949                 .mixers = { alc880_three_stack_mixer },
4950                 .init_verbs = { alc880_volume_init_verbs,
4951                                 alc880_pin_clevo_init_verbs },
4952                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4953                 .dac_nids = alc880_dac_nids,
4954                 .hp_nid = 0x03,
4955                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4956                 .channel_mode = alc880_threestack_modes,
4957                 .need_dac_fix = 1,
4958                 .input_mux = &alc880_capture_source,
4959         },
4960         [ALC880_LG] = {
4961                 .mixers = { alc880_lg_mixer },
4962                 .init_verbs = { alc880_volume_init_verbs,
4963                                 alc880_lg_init_verbs },
4964                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4965                 .dac_nids = alc880_lg_dac_nids,
4966                 .dig_out_nid = ALC880_DIGOUT_NID,
4967                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4968                 .channel_mode = alc880_lg_ch_modes,
4969                 .need_dac_fix = 1,
4970                 .input_mux = &alc880_lg_capture_source,
4971                 .unsol_event = alc_automute_amp_unsol_event,
4972                 .setup = alc880_lg_setup,
4973                 .init_hook = alc_automute_amp,
4974 #ifdef CONFIG_SND_HDA_POWER_SAVE
4975                 .loopbacks = alc880_lg_loopbacks,
4976 #endif
4977         },
4978         [ALC880_LG_LW] = {
4979                 .mixers = { alc880_lg_lw_mixer },
4980                 .init_verbs = { alc880_volume_init_verbs,
4981                                 alc880_lg_lw_init_verbs },
4982                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4983                 .dac_nids = alc880_dac_nids,
4984                 .dig_out_nid = ALC880_DIGOUT_NID,
4985                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4986                 .channel_mode = alc880_lg_lw_modes,
4987                 .input_mux = &alc880_lg_lw_capture_source,
4988                 .unsol_event = alc_automute_amp_unsol_event,
4989                 .setup = alc880_lg_lw_setup,
4990                 .init_hook = alc_automute_amp,
4991         },
4992         [ALC880_MEDION_RIM] = {
4993                 .mixers = { alc880_medion_rim_mixer },
4994                 .init_verbs = { alc880_volume_init_verbs,
4995                                 alc880_medion_rim_init_verbs,
4996                                 alc_gpio2_init_verbs },
4997                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4998                 .dac_nids = alc880_dac_nids,
4999                 .dig_out_nid = ALC880_DIGOUT_NID,
5000                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5001                 .channel_mode = alc880_2_jack_modes,
5002                 .input_mux = &alc880_medion_rim_capture_source,
5003                 .unsol_event = alc880_medion_rim_unsol_event,
5004                 .setup = alc880_medion_rim_setup,
5005                 .init_hook = alc880_medion_rim_automute,
5006         },
5007 #ifdef CONFIG_SND_DEBUG
5008         [ALC880_TEST] = {
5009                 .mixers = { alc880_test_mixer },
5010                 .init_verbs = { alc880_test_init_verbs },
5011                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
5012                 .dac_nids = alc880_test_dac_nids,
5013                 .dig_out_nid = ALC880_DIGOUT_NID,
5014                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
5015                 .channel_mode = alc880_test_modes,
5016                 .input_mux = &alc880_test_capture_source,
5017         },
5018 #endif
5019 };
5020
5021 /*
5022  * Automatic parse of I/O pins from the BIOS configuration
5023  */
5024
5025 enum {
5026         ALC_CTL_WIDGET_VOL,
5027         ALC_CTL_WIDGET_MUTE,
5028         ALC_CTL_BIND_MUTE,
5029 };
5030 static struct snd_kcontrol_new alc880_control_templates[] = {
5031         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
5032         HDA_CODEC_MUTE(NULL, 0, 0, 0),
5033         HDA_BIND_MUTE(NULL, 0, 0, 0),
5034 };
5035
5036 /* add dynamic controls */
5037 static int add_control(struct alc_spec *spec, int type, const char *name,
5038                        int cidx, unsigned long val)
5039 {
5040         struct snd_kcontrol_new *knew;
5041
5042         snd_array_init(&spec->kctls, sizeof(*knew), 32);
5043         knew = snd_array_new(&spec->kctls);
5044         if (!knew)
5045                 return -ENOMEM;
5046         *knew = alc880_control_templates[type];
5047         knew->name = kstrdup(name, GFP_KERNEL);
5048         if (!knew->name)
5049                 return -ENOMEM;
5050         knew->index = cidx;
5051         if (get_amp_nid_(val))
5052                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5053         knew->private_value = val;
5054         return 0;
5055 }
5056
5057 static int add_control_with_pfx(struct alc_spec *spec, int type,
5058                                 const char *pfx, const char *dir,
5059                                 const char *sfx, int cidx, unsigned long val)
5060 {
5061         char name[32];
5062         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5063         return add_control(spec, type, name, cidx, val);
5064 }
5065
5066 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
5067         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5068 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
5069         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5070 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
5071         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5072 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
5073         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5074
5075 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
5076 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
5077 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
5078 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
5079 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
5080 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
5081 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
5082 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
5083 #define ALC880_PIN_CD_NID               0x1c
5084
5085 /* fill in the dac_nids table from the parsed pin configuration */
5086 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5087                                      const struct auto_pin_cfg *cfg)
5088 {
5089         hda_nid_t nid;
5090         int assigned[4];
5091         int i, j;
5092
5093         memset(assigned, 0, sizeof(assigned));
5094         spec->multiout.dac_nids = spec->private_dac_nids;
5095
5096         /* check the pins hardwired to audio widget */
5097         for (i = 0; i < cfg->line_outs; i++) {
5098                 nid = cfg->line_out_pins[i];
5099                 if (alc880_is_fixed_pin(nid)) {
5100                         int idx = alc880_fixed_pin_idx(nid);
5101                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
5102                         assigned[idx] = 1;
5103                 }
5104         }
5105         /* left pins can be connect to any audio widget */
5106         for (i = 0; i < cfg->line_outs; i++) {
5107                 nid = cfg->line_out_pins[i];
5108                 if (alc880_is_fixed_pin(nid))
5109                         continue;
5110                 /* search for an empty channel */
5111                 for (j = 0; j < cfg->line_outs; j++) {
5112                         if (!assigned[j]) {
5113                                 spec->multiout.dac_nids[i] =
5114                                         alc880_idx_to_dac(j);
5115                                 assigned[j] = 1;
5116                                 break;
5117                         }
5118                 }
5119         }
5120         spec->multiout.num_dacs = cfg->line_outs;
5121         return 0;
5122 }
5123
5124 static const char *alc_get_line_out_pfx(const struct auto_pin_cfg *cfg,
5125                                         bool can_be_master)
5126 {
5127         if (!cfg->hp_outs && !cfg->speaker_outs && can_be_master)
5128                 return "Master";
5129
5130         switch (cfg->line_out_type) {
5131         case AUTO_PIN_SPEAKER_OUT:
5132                 return "Speaker";
5133         case AUTO_PIN_HP_OUT:
5134                 return "Headphone";
5135         default:
5136                 if (cfg->line_outs == 1)
5137                         return "PCM";
5138                 break;
5139         }
5140         return NULL;
5141 }
5142
5143 /* add playback controls from the parsed DAC table */
5144 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5145                                              const struct auto_pin_cfg *cfg)
5146 {
5147         static const char * const chname[4] = {
5148                 "Front", "Surround", NULL /*CLFE*/, "Side"
5149         };
5150         const char *pfx = alc_get_line_out_pfx(cfg, false);
5151         hda_nid_t nid;
5152         int i, err;
5153
5154         for (i = 0; i < cfg->line_outs; i++) {
5155                 if (!spec->multiout.dac_nids[i])
5156                         continue;
5157                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5158                 if (!pfx && i == 2) {
5159                         /* Center/LFE */
5160                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5161                                               "Center",
5162                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5163                                                               HDA_OUTPUT));
5164                         if (err < 0)
5165                                 return err;
5166                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5167                                               "LFE",
5168                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5169                                                               HDA_OUTPUT));
5170                         if (err < 0)
5171                                 return err;
5172                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5173                                              "Center",
5174                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5175                                                               HDA_INPUT));
5176                         if (err < 0)
5177                                 return err;
5178                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5179                                              "LFE",
5180                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5181                                                               HDA_INPUT));
5182                         if (err < 0)
5183                                 return err;
5184                 } else {
5185                         const char *name = pfx;
5186                         if (!name)
5187                                 name = chname[i];
5188                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5189                                                 name, i,
5190                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5191                                                               HDA_OUTPUT));
5192                         if (err < 0)
5193                                 return err;
5194                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5195                                                name, i,
5196                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5197                                                               HDA_INPUT));
5198                         if (err < 0)
5199                                 return err;
5200                 }
5201         }
5202         return 0;
5203 }
5204
5205 /* add playback controls for speaker and HP outputs */
5206 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5207                                         const char *pfx)
5208 {
5209         hda_nid_t nid;
5210         int err;
5211
5212         if (!pin)
5213                 return 0;
5214
5215         if (alc880_is_fixed_pin(pin)) {
5216                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5217                 /* specify the DAC as the extra output */
5218                 if (!spec->multiout.hp_nid)
5219                         spec->multiout.hp_nid = nid;
5220                 else
5221                         spec->multiout.extra_out_nid[0] = nid;
5222                 /* control HP volume/switch on the output mixer amp */
5223                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5224                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5225                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5226                 if (err < 0)
5227                         return err;
5228                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5229                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5230                 if (err < 0)
5231                         return err;
5232         } else if (alc880_is_multi_pin(pin)) {
5233                 /* set manual connection */
5234                 /* we have only a switch on HP-out PIN */
5235                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5236                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5237                 if (err < 0)
5238                         return err;
5239         }
5240         return 0;
5241 }
5242
5243 /* create input playback/capture controls for the given pin */
5244 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5245                             const char *ctlname, int ctlidx,
5246                             int idx, hda_nid_t mix_nid)
5247 {
5248         int err;
5249
5250         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5251                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5252         if (err < 0)
5253                 return err;
5254         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5255                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5256         if (err < 0)
5257                 return err;
5258         return 0;
5259 }
5260
5261 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5262 {
5263         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5264         return (pincap & AC_PINCAP_IN) != 0;
5265 }
5266
5267 /* create playback/capture controls for input pins */
5268 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5269                                       const struct auto_pin_cfg *cfg,
5270                                       hda_nid_t mixer,
5271                                       hda_nid_t cap1, hda_nid_t cap2)
5272 {
5273         struct alc_spec *spec = codec->spec;
5274         struct hda_input_mux *imux = &spec->private_imux[0];
5275         int i, err, idx, type_idx = 0;
5276         const char *prev_label = NULL;
5277
5278         for (i = 0; i < cfg->num_inputs; i++) {
5279                 hda_nid_t pin;
5280                 const char *label;
5281
5282                 pin = cfg->inputs[i].pin;
5283                 if (!alc_is_input_pin(codec, pin))
5284                         continue;
5285
5286                 label = hda_get_autocfg_input_label(codec, cfg, i);
5287                 if (prev_label && !strcmp(label, prev_label))
5288                         type_idx++;
5289                 else
5290                         type_idx = 0;
5291                 prev_label = label;
5292
5293                 if (mixer) {
5294                         idx = get_connection_index(codec, mixer, pin);
5295                         if (idx >= 0) {
5296                                 err = new_analog_input(spec, pin,
5297                                                        label, type_idx,
5298                                                        idx, mixer);
5299                                 if (err < 0)
5300                                         return err;
5301                         }
5302                 }
5303
5304                 if (!cap1)
5305                         continue;
5306                 idx = get_connection_index(codec, cap1, pin);
5307                 if (idx < 0 && cap2)
5308                         idx = get_connection_index(codec, cap2, pin);
5309                 if (idx >= 0)
5310                         snd_hda_add_imux_item(imux, label, idx, NULL);
5311         }
5312         return 0;
5313 }
5314
5315 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5316                                                 const struct auto_pin_cfg *cfg)
5317 {
5318         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5319 }
5320
5321 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5322                                unsigned int pin_type)
5323 {
5324         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5325                             pin_type);
5326         /* unmute pin */
5327         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5328                             AMP_OUT_UNMUTE);
5329 }
5330
5331 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5332                                               hda_nid_t nid, int pin_type,
5333                                               int dac_idx)
5334 {
5335         alc_set_pin_output(codec, nid, pin_type);
5336         /* need the manual connection? */
5337         if (alc880_is_multi_pin(nid)) {
5338                 struct alc_spec *spec = codec->spec;
5339                 int idx = alc880_multi_pin_idx(nid);
5340                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5341                                     AC_VERB_SET_CONNECT_SEL,
5342                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5343         }
5344 }
5345
5346 static int get_pin_type(int line_out_type)
5347 {
5348         if (line_out_type == AUTO_PIN_HP_OUT)
5349                 return PIN_HP;
5350         else
5351                 return PIN_OUT;
5352 }
5353
5354 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5355 {
5356         struct alc_spec *spec = codec->spec;
5357         int i;
5358
5359         for (i = 0; i < spec->autocfg.line_outs; i++) {
5360                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5361                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5362                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5363         }
5364 }
5365
5366 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5367 {
5368         struct alc_spec *spec = codec->spec;
5369         hda_nid_t pin;
5370
5371         pin = spec->autocfg.speaker_pins[0];
5372         if (pin) /* connect to front */
5373                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5374         pin = spec->autocfg.hp_pins[0];
5375         if (pin) /* connect to front */
5376                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5377 }
5378
5379 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5380 {
5381         struct alc_spec *spec = codec->spec;
5382         struct auto_pin_cfg *cfg = &spec->autocfg;
5383         int i;
5384
5385         for (i = 0; i < cfg->num_inputs; i++) {
5386                 hda_nid_t nid = cfg->inputs[i].pin;
5387                 if (alc_is_input_pin(codec, nid)) {
5388                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5389                         if (nid != ALC880_PIN_CD_NID &&
5390                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5391                                 snd_hda_codec_write(codec, nid, 0,
5392                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5393                                                     AMP_OUT_MUTE);
5394                 }
5395         }
5396 }
5397
5398 static void alc880_auto_init_input_src(struct hda_codec *codec)
5399 {
5400         struct alc_spec *spec = codec->spec;
5401         int c;
5402
5403         for (c = 0; c < spec->num_adc_nids; c++) {
5404                 unsigned int mux_idx;
5405                 const struct hda_input_mux *imux;
5406                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5407                 imux = &spec->input_mux[mux_idx];
5408                 if (!imux->num_items && mux_idx > 0)
5409                         imux = &spec->input_mux[0];
5410                 if (imux)
5411                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5412                                             AC_VERB_SET_CONNECT_SEL,
5413                                             imux->items[0].index);
5414         }
5415 }
5416
5417 /* parse the BIOS configuration and set up the alc_spec */
5418 /* return 1 if successful, 0 if the proper config is not found,
5419  * or a negative error code
5420  */
5421 static int alc880_parse_auto_config(struct hda_codec *codec)
5422 {
5423         struct alc_spec *spec = codec->spec;
5424         int err;
5425         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5426
5427         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5428                                            alc880_ignore);
5429         if (err < 0)
5430                 return err;
5431         if (!spec->autocfg.line_outs)
5432                 return 0; /* can't find valid BIOS pin config */
5433
5434         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5435         if (err < 0)
5436                 return err;
5437         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5438         if (err < 0)
5439                 return err;
5440         err = alc880_auto_create_extra_out(spec,
5441                                            spec->autocfg.speaker_pins[0],
5442                                            "Speaker");
5443         if (err < 0)
5444                 return err;
5445         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5446                                            "Headphone");
5447         if (err < 0)
5448                 return err;
5449         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5450         if (err < 0)
5451                 return err;
5452
5453         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5454
5455         alc_auto_parse_digital(codec);
5456
5457         if (spec->kctls.list)
5458                 add_mixer(spec, spec->kctls.list);
5459
5460         add_verb(spec, alc880_volume_init_verbs);
5461
5462         spec->num_mux_defs = 1;
5463         spec->input_mux = &spec->private_imux[0];
5464
5465         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5466
5467         return 1;
5468 }
5469
5470 /* additional initialization for auto-configuration model */
5471 static void alc880_auto_init(struct hda_codec *codec)
5472 {
5473         struct alc_spec *spec = codec->spec;
5474         alc880_auto_init_multi_out(codec);
5475         alc880_auto_init_extra_out(codec);
5476         alc880_auto_init_analog_input(codec);
5477         alc880_auto_init_input_src(codec);
5478         alc_auto_init_digital(codec);
5479         if (spec->unsol_event)
5480                 alc_inithook(codec);
5481 }
5482
5483 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5484  * one of two digital mic pins, e.g. on ALC272
5485  */
5486 static void fixup_automic_adc(struct hda_codec *codec)
5487 {
5488         struct alc_spec *spec = codec->spec;
5489         int i;
5490
5491         for (i = 0; i < spec->num_adc_nids; i++) {
5492                 hda_nid_t cap = spec->capsrc_nids ?
5493                         spec->capsrc_nids[i] : spec->adc_nids[i];
5494                 int iidx, eidx;
5495
5496                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5497                 if (iidx < 0)
5498                         continue;
5499                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5500                 if (eidx < 0)
5501                         continue;
5502                 spec->int_mic.mux_idx = iidx;
5503                 spec->ext_mic.mux_idx = eidx;
5504                 if (spec->capsrc_nids)
5505                         spec->capsrc_nids += i;
5506                 spec->adc_nids += i;
5507                 spec->num_adc_nids = 1;
5508                 return;
5509         }
5510         snd_printd(KERN_INFO "hda_codec: %s: "
5511                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5512                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5513         spec->auto_mic = 0; /* disable auto-mic to be sure */
5514 }
5515
5516 /* select or unmute the given capsrc route */
5517 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5518                                     int idx)
5519 {
5520         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5521                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5522                                          HDA_AMP_MUTE, 0);
5523         } else {
5524                 snd_hda_codec_write_cache(codec, cap, 0,
5525                                           AC_VERB_SET_CONNECT_SEL, idx);
5526         }
5527 }
5528
5529 /* set the default connection to that pin */
5530 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5531 {
5532         struct alc_spec *spec = codec->spec;
5533         int i;
5534
5535         for (i = 0; i < spec->num_adc_nids; i++) {
5536                 hda_nid_t cap = spec->capsrc_nids ?
5537                         spec->capsrc_nids[i] : spec->adc_nids[i];
5538                 int idx;
5539
5540                 idx = get_connection_index(codec, cap, pin);
5541                 if (idx < 0)
5542                         continue;
5543                 select_or_unmute_capsrc(codec, cap, idx);
5544                 return i; /* return the found index */
5545         }
5546         return -1; /* not found */
5547 }
5548
5549 /* choose the ADC/MUX containing the input pin and initialize the setup */
5550 static void fixup_single_adc(struct hda_codec *codec)
5551 {
5552         struct alc_spec *spec = codec->spec;
5553         struct auto_pin_cfg *cfg = &spec->autocfg;
5554         int i;
5555
5556         /* search for the input pin; there must be only one */
5557         if (cfg->num_inputs != 1)
5558                 return;
5559         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5560         if (i >= 0) {
5561                 /* use only this ADC */
5562                 if (spec->capsrc_nids)
5563                         spec->capsrc_nids += i;
5564                 spec->adc_nids += i;
5565                 spec->num_adc_nids = 1;
5566         }
5567 }
5568
5569 /* initialize dual adcs */
5570 static void fixup_dual_adc_switch(struct hda_codec *codec)
5571 {
5572         struct alc_spec *spec = codec->spec;
5573         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5574         init_capsrc_for_pin(codec, spec->int_mic.pin);
5575 }
5576
5577 static void set_capture_mixer(struct hda_codec *codec)
5578 {
5579         struct alc_spec *spec = codec->spec;
5580         static struct snd_kcontrol_new *caps[2][3] = {
5581                 { alc_capture_mixer_nosrc1,
5582                   alc_capture_mixer_nosrc2,
5583                   alc_capture_mixer_nosrc3 },
5584                 { alc_capture_mixer1,
5585                   alc_capture_mixer2,
5586                   alc_capture_mixer3 },
5587         };
5588         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5589                 int mux = 0;
5590                 int num_adcs = spec->num_adc_nids;
5591                 if (spec->dual_adc_switch)
5592                         fixup_dual_adc_switch(codec);
5593                 else if (spec->auto_mic)
5594                         fixup_automic_adc(codec);
5595                 else if (spec->input_mux) {
5596                         if (spec->input_mux->num_items > 1)
5597                                 mux = 1;
5598                         else if (spec->input_mux->num_items == 1)
5599                                 fixup_single_adc(codec);
5600                 }
5601                 if (spec->dual_adc_switch)
5602                         num_adcs = 1;
5603                 spec->cap_mixer = caps[mux][num_adcs - 1];
5604         }
5605 }
5606
5607 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5608 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5609                                  int num_nids)
5610 {
5611         struct alc_spec *spec = codec->spec;
5612         struct auto_pin_cfg *cfg = &spec->autocfg;
5613         int n;
5614         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5615
5616         for (n = 0; n < num_nids; n++) {
5617                 hda_nid_t adc, cap;
5618                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5619                 int nconns, i, j;
5620
5621                 adc = nids[n];
5622                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5623                         continue;
5624                 cap = adc;
5625                 nconns = snd_hda_get_connections(codec, cap, conn,
5626                                                  ARRAY_SIZE(conn));
5627                 if (nconns == 1) {
5628                         cap = conn[0];
5629                         nconns = snd_hda_get_connections(codec, cap, conn,
5630                                                          ARRAY_SIZE(conn));
5631                 }
5632                 if (nconns <= 0)
5633                         continue;
5634                 if (!fallback_adc) {
5635                         fallback_adc = adc;
5636                         fallback_cap = cap;
5637                 }
5638                 for (i = 0; i < cfg->num_inputs; i++) {
5639                         hda_nid_t nid = cfg->inputs[i].pin;
5640                         for (j = 0; j < nconns; j++) {
5641                                 if (conn[j] == nid)
5642                                         break;
5643                         }
5644                         if (j >= nconns)
5645                                 break;
5646                 }
5647                 if (i >= cfg->num_inputs) {
5648                         int num_adcs = spec->num_adc_nids;
5649                         spec->private_adc_nids[num_adcs] = adc;
5650                         spec->private_capsrc_nids[num_adcs] = cap;
5651                         spec->num_adc_nids++;
5652                         spec->adc_nids = spec->private_adc_nids;
5653                         if (adc != cap)
5654                                 spec->capsrc_nids = spec->private_capsrc_nids;
5655                 }
5656         }
5657         if (!spec->num_adc_nids) {
5658                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5659                        " using fallback 0x%x\n",
5660                        codec->chip_name, fallback_adc);
5661                 spec->private_adc_nids[0] = fallback_adc;
5662                 spec->adc_nids = spec->private_adc_nids;
5663                 if (fallback_adc != fallback_cap) {
5664                         spec->private_capsrc_nids[0] = fallback_cap;
5665                         spec->capsrc_nids = spec->private_adc_nids;
5666                 }
5667         }
5668 }
5669
5670 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5671 #define set_beep_amp(spec, nid, idx, dir) \
5672         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5673
5674 static struct snd_pci_quirk beep_white_list[] = {
5675         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5676         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5677         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5678         {}
5679 };
5680
5681 static inline int has_cdefine_beep(struct hda_codec *codec)
5682 {
5683         struct alc_spec *spec = codec->spec;
5684         const struct snd_pci_quirk *q;
5685         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5686         if (q)
5687                 return q->value;
5688         return spec->cdefine.enable_pcbeep;
5689 }
5690 #else
5691 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5692 #define has_cdefine_beep(codec)         0
5693 #endif
5694
5695 /*
5696  * OK, here we have finally the patch for ALC880
5697  */
5698
5699 static int patch_alc880(struct hda_codec *codec)
5700 {
5701         struct alc_spec *spec;
5702         int board_config;
5703         int err;
5704
5705         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5706         if (spec == NULL)
5707                 return -ENOMEM;
5708
5709         codec->spec = spec;
5710
5711         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5712                                                   alc880_models,
5713                                                   alc880_cfg_tbl);
5714         if (board_config < 0) {
5715                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5716                        codec->chip_name);
5717                 board_config = ALC880_AUTO;
5718         }
5719
5720         if (board_config == ALC880_AUTO) {
5721                 /* automatic parse from the BIOS config */
5722                 err = alc880_parse_auto_config(codec);
5723                 if (err < 0) {
5724                         alc_free(codec);
5725                         return err;
5726                 } else if (!err) {
5727                         printk(KERN_INFO
5728                                "hda_codec: Cannot set up configuration "
5729                                "from BIOS.  Using 3-stack mode...\n");
5730                         board_config = ALC880_3ST;
5731                 }
5732         }
5733
5734         err = snd_hda_attach_beep_device(codec, 0x1);
5735         if (err < 0) {
5736                 alc_free(codec);
5737                 return err;
5738         }
5739
5740         if (board_config != ALC880_AUTO)
5741                 setup_preset(codec, &alc880_presets[board_config]);
5742
5743         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5744         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5745         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5746
5747         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5748         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5749
5750         if (!spec->adc_nids && spec->input_mux) {
5751                 /* check whether NID 0x07 is valid */
5752                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5753                 /* get type */
5754                 wcap = get_wcaps_type(wcap);
5755                 if (wcap != AC_WID_AUD_IN) {
5756                         spec->adc_nids = alc880_adc_nids_alt;
5757                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5758                 } else {
5759                         spec->adc_nids = alc880_adc_nids;
5760                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5761                 }
5762         }
5763         set_capture_mixer(codec);
5764         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5765
5766         spec->vmaster_nid = 0x0c;
5767
5768         codec->patch_ops = alc_patch_ops;
5769         if (board_config == ALC880_AUTO)
5770                 spec->init_hook = alc880_auto_init;
5771 #ifdef CONFIG_SND_HDA_POWER_SAVE
5772         if (!spec->loopback.amplist)
5773                 spec->loopback.amplist = alc880_loopbacks;
5774 #endif
5775
5776         return 0;
5777 }
5778
5779
5780 /*
5781  * ALC260 support
5782  */
5783
5784 static hda_nid_t alc260_dac_nids[1] = {
5785         /* front */
5786         0x02,
5787 };
5788
5789 static hda_nid_t alc260_adc_nids[1] = {
5790         /* ADC0 */
5791         0x04,
5792 };
5793
5794 static hda_nid_t alc260_adc_nids_alt[1] = {
5795         /* ADC1 */
5796         0x05,
5797 };
5798
5799 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5800  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5801  */
5802 static hda_nid_t alc260_dual_adc_nids[2] = {
5803         /* ADC0, ADC1 */
5804         0x04, 0x05
5805 };
5806
5807 #define ALC260_DIGOUT_NID       0x03
5808 #define ALC260_DIGIN_NID        0x06
5809
5810 static struct hda_input_mux alc260_capture_source = {
5811         .num_items = 4,
5812         .items = {
5813                 { "Mic", 0x0 },
5814                 { "Front Mic", 0x1 },
5815                 { "Line", 0x2 },
5816                 { "CD", 0x4 },
5817         },
5818 };
5819
5820 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5821  * headphone jack and the internal CD lines since these are the only pins at
5822  * which audio can appear.  For flexibility, also allow the option of
5823  * recording the mixer output on the second ADC (ADC0 doesn't have a
5824  * connection to the mixer output).
5825  */
5826 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5827         {
5828                 .num_items = 3,
5829                 .items = {
5830                         { "Mic/Line", 0x0 },
5831                         { "CD", 0x4 },
5832                         { "Headphone", 0x2 },
5833                 },
5834         },
5835         {
5836                 .num_items = 4,
5837                 .items = {
5838                         { "Mic/Line", 0x0 },
5839                         { "CD", 0x4 },
5840                         { "Headphone", 0x2 },
5841                         { "Mixer", 0x5 },
5842                 },
5843         },
5844
5845 };
5846
5847 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5848  * the Fujitsu S702x, but jacks are marked differently.
5849  */
5850 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5851         {
5852                 .num_items = 4,
5853                 .items = {
5854                         { "Mic", 0x0 },
5855                         { "Line", 0x2 },
5856                         { "CD", 0x4 },
5857                         { "Headphone", 0x5 },
5858                 },
5859         },
5860         {
5861                 .num_items = 5,
5862                 .items = {
5863                         { "Mic", 0x0 },
5864                         { "Line", 0x2 },
5865                         { "CD", 0x4 },
5866                         { "Headphone", 0x6 },
5867                         { "Mixer", 0x5 },
5868                 },
5869         },
5870 };
5871
5872 /* Maxdata Favorit 100XS */
5873 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5874         {
5875                 .num_items = 2,
5876                 .items = {
5877                         { "Line/Mic", 0x0 },
5878                         { "CD", 0x4 },
5879                 },
5880         },
5881         {
5882                 .num_items = 3,
5883                 .items = {
5884                         { "Line/Mic", 0x0 },
5885                         { "CD", 0x4 },
5886                         { "Mixer", 0x5 },
5887                 },
5888         },
5889 };
5890
5891 /*
5892  * This is just place-holder, so there's something for alc_build_pcms to look
5893  * at when it calculates the maximum number of channels. ALC260 has no mixer
5894  * element which allows changing the channel mode, so the verb list is
5895  * never used.
5896  */
5897 static struct hda_channel_mode alc260_modes[1] = {
5898         { 2, NULL },
5899 };
5900
5901
5902 /* Mixer combinations
5903  *
5904  * basic: base_output + input + pc_beep + capture
5905  * HP: base_output + input + capture_alt
5906  * HP_3013: hp_3013 + input + capture
5907  * fujitsu: fujitsu + capture
5908  * acer: acer + capture
5909  */
5910
5911 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5912         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5913         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5914         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5915         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5916         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5917         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5918         { } /* end */
5919 };
5920
5921 static struct snd_kcontrol_new alc260_input_mixer[] = {
5922         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5923         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5924         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5925         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5926         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5927         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5928         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5929         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5930         { } /* end */
5931 };
5932
5933 /* update HP, line and mono out pins according to the master switch */
5934 static void alc260_hp_master_update(struct hda_codec *codec,
5935                                     hda_nid_t hp, hda_nid_t line,
5936                                     hda_nid_t mono)
5937 {
5938         struct alc_spec *spec = codec->spec;
5939         unsigned int val = spec->master_sw ? PIN_HP : 0;
5940         /* change HP and line-out pins */
5941         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5942                             val);
5943         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5944                             val);
5945         /* mono (speaker) depending on the HP jack sense */
5946         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5947         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5948                             val);
5949 }
5950
5951 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5952                                    struct snd_ctl_elem_value *ucontrol)
5953 {
5954         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5955         struct alc_spec *spec = codec->spec;
5956         *ucontrol->value.integer.value = spec->master_sw;
5957         return 0;
5958 }
5959
5960 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5961                                    struct snd_ctl_elem_value *ucontrol)
5962 {
5963         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5964         struct alc_spec *spec = codec->spec;
5965         int val = !!*ucontrol->value.integer.value;
5966         hda_nid_t hp, line, mono;
5967
5968         if (val == spec->master_sw)
5969                 return 0;
5970         spec->master_sw = val;
5971         hp = (kcontrol->private_value >> 16) & 0xff;
5972         line = (kcontrol->private_value >> 8) & 0xff;
5973         mono = kcontrol->private_value & 0xff;
5974         alc260_hp_master_update(codec, hp, line, mono);
5975         return 1;
5976 }
5977
5978 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5979         {
5980                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5981                 .name = "Master Playback Switch",
5982                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5983                 .info = snd_ctl_boolean_mono_info,
5984                 .get = alc260_hp_master_sw_get,
5985                 .put = alc260_hp_master_sw_put,
5986                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5987         },
5988         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5989         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5990         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5991         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5992         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5993                               HDA_OUTPUT),
5994         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5995         { } /* end */
5996 };
5997
5998 static struct hda_verb alc260_hp_unsol_verbs[] = {
5999         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6000         {},
6001 };
6002
6003 static void alc260_hp_automute(struct hda_codec *codec)
6004 {
6005         struct alc_spec *spec = codec->spec;
6006
6007         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
6008         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
6009 }
6010
6011 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
6012 {
6013         if ((res >> 26) == ALC880_HP_EVENT)
6014                 alc260_hp_automute(codec);
6015 }
6016
6017 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
6018         {
6019                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6020                 .name = "Master Playback Switch",
6021                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6022                 .info = snd_ctl_boolean_mono_info,
6023                 .get = alc260_hp_master_sw_get,
6024                 .put = alc260_hp_master_sw_put,
6025                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
6026         },
6027         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6028         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6029         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
6030         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
6031         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6032         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6033         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6034         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
6035         { } /* end */
6036 };
6037
6038 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
6039         .ops = &snd_hda_bind_vol,
6040         .values = {
6041                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
6042                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
6043                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
6044                 0
6045         },
6046 };
6047
6048 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
6049         .ops = &snd_hda_bind_sw,
6050         .values = {
6051                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
6052                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
6053                 0
6054         },
6055 };
6056
6057 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
6058         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
6059         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
6060         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
6061         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6062         { } /* end */
6063 };
6064
6065 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
6066         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6067         {},
6068 };
6069
6070 static void alc260_hp_3013_automute(struct hda_codec *codec)
6071 {
6072         struct alc_spec *spec = codec->spec;
6073
6074         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
6075         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
6076 }
6077
6078 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
6079                                        unsigned int res)
6080 {
6081         if ((res >> 26) == ALC880_HP_EVENT)
6082                 alc260_hp_3013_automute(codec);
6083 }
6084
6085 static void alc260_hp_3012_automute(struct hda_codec *codec)
6086 {
6087         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
6088
6089         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6090                             bits);
6091         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6092                             bits);
6093         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6094                             bits);
6095 }
6096
6097 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
6098                                        unsigned int res)
6099 {
6100         if ((res >> 26) == ALC880_HP_EVENT)
6101                 alc260_hp_3012_automute(codec);
6102 }
6103
6104 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6105  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6106  */
6107 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6108         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6109         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6110         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6111         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6112         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6113         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6114         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6115         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6116         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6117         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6118         { } /* end */
6119 };
6120
6121 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6122  * versions of the ALC260 don't act on requests to enable mic bias from NID
6123  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6124  * datasheet doesn't mention this restriction.  At this stage it's not clear
6125  * whether this behaviour is intentional or is a hardware bug in chip
6126  * revisions available in early 2006.  Therefore for now allow the
6127  * "Headphone Jack Mode" control to span all choices, but if it turns out
6128  * that the lack of mic bias for this NID is intentional we could change the
6129  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6130  *
6131  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6132  * don't appear to make the mic bias available from the "line" jack, even
6133  * though the NID used for this jack (0x14) can supply it.  The theory is
6134  * that perhaps Acer have included blocking capacitors between the ALC260
6135  * and the output jack.  If this turns out to be the case for all such
6136  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6137  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6138  *
6139  * The C20x Tablet series have a mono internal speaker which is controlled
6140  * via the chip's Mono sum widget and pin complex, so include the necessary
6141  * controls for such models.  On models without a "mono speaker" the control
6142  * won't do anything.
6143  */
6144 static struct snd_kcontrol_new alc260_acer_mixer[] = {
6145         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6146         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6147         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6148         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6149                               HDA_OUTPUT),
6150         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6151                            HDA_INPUT),
6152         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6153         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6154         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6155         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6156         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6157         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6158         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6159         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6160         { } /* end */
6161 };
6162
6163 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6164  */
6165 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6166         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6167         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6168         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6169         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6170         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6171         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6172         { } /* end */
6173 };
6174
6175 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6176  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6177  */
6178 static struct snd_kcontrol_new alc260_will_mixer[] = {
6179         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6180         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6181         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6182         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6183         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6184         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6185         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6186         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6187         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6188         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6189         { } /* end */
6190 };
6191
6192 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6193  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6194  */
6195 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6196         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6197         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6198         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6199         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6200         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6201         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6202         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6203         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6204         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6205         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6206         { } /* end */
6207 };
6208
6209 /*
6210  * initialization verbs
6211  */
6212 static struct hda_verb alc260_init_verbs[] = {
6213         /* Line In pin widget for input */
6214         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6215         /* CD pin widget for input */
6216         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6217         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6218         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6219         /* Mic2 (front panel) pin widget for input and vref at 80% */
6220         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6221         /* LINE-2 is used for line-out in rear */
6222         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6223         /* select line-out */
6224         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6225         /* LINE-OUT pin */
6226         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6227         /* enable HP */
6228         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6229         /* enable Mono */
6230         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6231         /* mute capture amp left and right */
6232         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6233         /* set connection select to line in (default select for this ADC) */
6234         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6235         /* mute capture amp left and right */
6236         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6237         /* set connection select to line in (default select for this ADC) */
6238         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6239         /* set vol=0 Line-Out mixer amp left and right */
6240         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6241         /* unmute pin widget amp left and right (no gain on this amp) */
6242         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6243         /* set vol=0 HP mixer amp left and right */
6244         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6245         /* unmute pin widget amp left and right (no gain on this amp) */
6246         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6247         /* set vol=0 Mono mixer amp left and right */
6248         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6249         /* unmute pin widget amp left and right (no gain on this amp) */
6250         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6251         /* unmute LINE-2 out pin */
6252         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6253         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6254          * Line In 2 = 0x03
6255          */
6256         /* mute analog inputs */
6257         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6258         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6259         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6260         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6261         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6262         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6263         /* mute Front out path */
6264         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6265         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6266         /* mute Headphone out path */
6267         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6268         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6269         /* mute Mono out path */
6270         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6271         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6272         { }
6273 };
6274
6275 #if 0 /* should be identical with alc260_init_verbs? */
6276 static struct hda_verb alc260_hp_init_verbs[] = {
6277         /* Headphone and output */
6278         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6279         /* mono output */
6280         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6281         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6282         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6283         /* Mic2 (front panel) pin widget for input and vref at 80% */
6284         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6285         /* Line In pin widget for input */
6286         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6287         /* Line-2 pin widget for output */
6288         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6289         /* CD pin widget for input */
6290         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6291         /* unmute amp left and right */
6292         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6293         /* set connection select to line in (default select for this ADC) */
6294         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6295         /* unmute Line-Out mixer amp left and right (volume = 0) */
6296         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6297         /* mute pin widget amp left and right (no gain on this amp) */
6298         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6299         /* unmute HP mixer amp left and right (volume = 0) */
6300         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6301         /* mute pin widget amp left and right (no gain on this amp) */
6302         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6303         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6304          * Line In 2 = 0x03
6305          */
6306         /* mute analog inputs */
6307         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6308         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6309         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6310         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6311         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6312         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6313         /* Unmute Front out path */
6314         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6315         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6316         /* Unmute Headphone out path */
6317         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6318         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6319         /* Unmute Mono out path */
6320         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6321         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6322         { }
6323 };
6324 #endif
6325
6326 static struct hda_verb alc260_hp_3013_init_verbs[] = {
6327         /* Line out and output */
6328         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6329         /* mono output */
6330         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6331         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6332         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6333         /* Mic2 (front panel) pin widget for input and vref at 80% */
6334         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6335         /* Line In pin widget for input */
6336         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6337         /* Headphone pin widget for output */
6338         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6339         /* CD pin widget for input */
6340         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6341         /* unmute amp left and right */
6342         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6343         /* set connection select to line in (default select for this ADC) */
6344         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6345         /* unmute Line-Out mixer amp left and right (volume = 0) */
6346         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6347         /* mute pin widget amp left and right (no gain on this amp) */
6348         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6349         /* unmute HP mixer amp left and right (volume = 0) */
6350         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6351         /* mute pin widget amp left and right (no gain on this amp) */
6352         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6353         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6354          * Line In 2 = 0x03
6355          */
6356         /* mute analog inputs */
6357         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6358         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6359         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6360         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6361         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6362         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6363         /* Unmute Front out path */
6364         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6365         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6366         /* Unmute Headphone out path */
6367         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6368         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6369         /* Unmute Mono out path */
6370         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6371         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6372         { }
6373 };
6374
6375 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6376  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6377  * audio = 0x16, internal speaker = 0x10.
6378  */
6379 static struct hda_verb alc260_fujitsu_init_verbs[] = {
6380         /* Disable all GPIOs */
6381         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6382         /* Internal speaker is connected to headphone pin */
6383         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6384         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6385         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6386         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6387         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6388         /* Ensure all other unused pins are disabled and muted. */
6389         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6390         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6391         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6392         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6393         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6394         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6395         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6396         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6397
6398         /* Disable digital (SPDIF) pins */
6399         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6400         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6401
6402         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6403          * when acting as an output.
6404          */
6405         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6406
6407         /* Start with output sum widgets muted and their output gains at min */
6408         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6409         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6410         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6411         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6412         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6413         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6414         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6415         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6416         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6417
6418         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6419         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6420         /* Unmute Line1 pin widget output buffer since it starts as an output.
6421          * If the pin mode is changed by the user the pin mode control will
6422          * take care of enabling the pin's input/output buffers as needed.
6423          * Therefore there's no need to enable the input buffer at this
6424          * stage.
6425          */
6426         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6427         /* Unmute input buffer of pin widget used for Line-in (no equiv
6428          * mixer ctrl)
6429          */
6430         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6431
6432         /* Mute capture amp left and right */
6433         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6434         /* Set ADC connection select to match default mixer setting - line
6435          * in (on mic1 pin)
6436          */
6437         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6438
6439         /* Do the same for the second ADC: mute capture input amp and
6440          * set ADC connection to line in (on mic1 pin)
6441          */
6442         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6443         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6444
6445         /* Mute all inputs to mixer widget (even unconnected ones) */
6446         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6447         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6448         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6449         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6450         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6451         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6452         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6453         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6454
6455         { }
6456 };
6457
6458 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6459  * similar laptops (adapted from Fujitsu init verbs).
6460  */
6461 static struct hda_verb alc260_acer_init_verbs[] = {
6462         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6463          * the headphone jack.  Turn this on and rely on the standard mute
6464          * methods whenever the user wants to turn these outputs off.
6465          */
6466         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6467         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6468         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6469         /* Internal speaker/Headphone jack is connected to Line-out pin */
6470         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6471         /* Internal microphone/Mic jack is connected to Mic1 pin */
6472         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6473         /* Line In jack is connected to Line1 pin */
6474         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6475         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6476         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6477         /* Ensure all other unused pins are disabled and muted. */
6478         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6479         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6480         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6481         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6482         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6483         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6484         /* Disable digital (SPDIF) pins */
6485         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6486         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6487
6488         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6489          * bus when acting as outputs.
6490          */
6491         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6492         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6493
6494         /* Start with output sum widgets muted and their output gains at min */
6495         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6496         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6497         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6498         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6499         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6500         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6501         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6502         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6503         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6504
6505         /* Unmute Line-out pin widget amp left and right
6506          * (no equiv mixer ctrl)
6507          */
6508         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6509         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6510         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6511         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6512          * inputs. If the pin mode is changed by the user the pin mode control
6513          * will take care of enabling the pin's input/output buffers as needed.
6514          * Therefore there's no need to enable the input buffer at this
6515          * stage.
6516          */
6517         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6518         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6519
6520         /* Mute capture amp left and right */
6521         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6522         /* Set ADC connection select to match default mixer setting - mic
6523          * (on mic1 pin)
6524          */
6525         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6526
6527         /* Do similar with the second ADC: mute capture input amp and
6528          * set ADC connection to mic to match ALSA's default state.
6529          */
6530         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6531         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6532
6533         /* Mute all inputs to mixer widget (even unconnected ones) */
6534         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6535         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6536         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6537         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6538         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6539         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6540         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6541         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6542
6543         { }
6544 };
6545
6546 /* Initialisation sequence for Maxdata Favorit 100XS
6547  * (adapted from Acer init verbs).
6548  */
6549 static struct hda_verb alc260_favorit100_init_verbs[] = {
6550         /* GPIO 0 enables the output jack.
6551          * Turn this on and rely on the standard mute
6552          * methods whenever the user wants to turn these outputs off.
6553          */
6554         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6555         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6556         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6557         /* Line/Mic input jack is connected to Mic1 pin */
6558         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6559         /* Ensure all other unused pins are disabled and muted. */
6560         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6561         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6562         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6563         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6564         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6565         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6566         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6567         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6568         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6569         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6570         /* Disable digital (SPDIF) pins */
6571         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6572         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6573
6574         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6575          * bus when acting as outputs.
6576          */
6577         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6578         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6579
6580         /* Start with output sum widgets muted and their output gains at min */
6581         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6582         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6583         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6584         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6585         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6586         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6587         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6588         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6589         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6590
6591         /* Unmute Line-out pin widget amp left and right
6592          * (no equiv mixer ctrl)
6593          */
6594         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6595         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6596          * inputs. If the pin mode is changed by the user the pin mode control
6597          * will take care of enabling the pin's input/output buffers as needed.
6598          * Therefore there's no need to enable the input buffer at this
6599          * stage.
6600          */
6601         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6602
6603         /* Mute capture amp left and right */
6604         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6605         /* Set ADC connection select to match default mixer setting - mic
6606          * (on mic1 pin)
6607          */
6608         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6609
6610         /* Do similar with the second ADC: mute capture input amp and
6611          * set ADC connection to mic to match ALSA's default state.
6612          */
6613         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6614         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6615
6616         /* Mute all inputs to mixer widget (even unconnected ones) */
6617         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6618         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6619         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6620         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6621         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6622         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6623         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6624         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6625
6626         { }
6627 };
6628
6629 static struct hda_verb alc260_will_verbs[] = {
6630         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6631         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6632         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6633         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6634         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6635         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6636         {}
6637 };
6638
6639 static struct hda_verb alc260_replacer_672v_verbs[] = {
6640         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6641         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6642         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6643
6644         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6645         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6646         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6647
6648         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6649         {}
6650 };
6651
6652 /* toggle speaker-output according to the hp-jack state */
6653 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6654 {
6655         unsigned int present;
6656
6657         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6658         present = snd_hda_jack_detect(codec, 0x0f);
6659         if (present) {
6660                 snd_hda_codec_write_cache(codec, 0x01, 0,
6661                                           AC_VERB_SET_GPIO_DATA, 1);
6662                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6663                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6664                                           PIN_HP);
6665         } else {
6666                 snd_hda_codec_write_cache(codec, 0x01, 0,
6667                                           AC_VERB_SET_GPIO_DATA, 0);
6668                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6669                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6670                                           PIN_OUT);
6671         }
6672 }
6673
6674 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6675                                        unsigned int res)
6676 {
6677         if ((res >> 26) == ALC880_HP_EVENT)
6678                 alc260_replacer_672v_automute(codec);
6679 }
6680
6681 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6682         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6683         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6684         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6685         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6686         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6687         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6688         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6689         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6690         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6691         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6692         {}
6693 };
6694
6695 /* Test configuration for debugging, modelled after the ALC880 test
6696  * configuration.
6697  */
6698 #ifdef CONFIG_SND_DEBUG
6699 static hda_nid_t alc260_test_dac_nids[1] = {
6700         0x02,
6701 };
6702 static hda_nid_t alc260_test_adc_nids[2] = {
6703         0x04, 0x05,
6704 };
6705 /* For testing the ALC260, each input MUX needs its own definition since
6706  * the signal assignments are different.  This assumes that the first ADC
6707  * is NID 0x04.
6708  */
6709 static struct hda_input_mux alc260_test_capture_sources[2] = {
6710         {
6711                 .num_items = 7,
6712                 .items = {
6713                         { "MIC1 pin", 0x0 },
6714                         { "MIC2 pin", 0x1 },
6715                         { "LINE1 pin", 0x2 },
6716                         { "LINE2 pin", 0x3 },
6717                         { "CD pin", 0x4 },
6718                         { "LINE-OUT pin", 0x5 },
6719                         { "HP-OUT pin", 0x6 },
6720                 },
6721         },
6722         {
6723                 .num_items = 8,
6724                 .items = {
6725                         { "MIC1 pin", 0x0 },
6726                         { "MIC2 pin", 0x1 },
6727                         { "LINE1 pin", 0x2 },
6728                         { "LINE2 pin", 0x3 },
6729                         { "CD pin", 0x4 },
6730                         { "Mixer", 0x5 },
6731                         { "LINE-OUT pin", 0x6 },
6732                         { "HP-OUT pin", 0x7 },
6733                 },
6734         },
6735 };
6736 static struct snd_kcontrol_new alc260_test_mixer[] = {
6737         /* Output driver widgets */
6738         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6739         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6740         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6741         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6742         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6743         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6744
6745         /* Modes for retasking pin widgets
6746          * Note: the ALC260 doesn't seem to act on requests to enable mic
6747          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6748          * mention this restriction.  At this stage it's not clear whether
6749          * this behaviour is intentional or is a hardware bug in chip
6750          * revisions available at least up until early 2006.  Therefore for
6751          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6752          * choices, but if it turns out that the lack of mic bias for these
6753          * NIDs is intentional we could change their modes from
6754          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6755          */
6756         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6757         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6758         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6759         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6760         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6761         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6762
6763         /* Loopback mixer controls */
6764         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6765         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6766         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6767         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6768         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6769         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6770         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6771         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6772         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6773         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6774         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6775         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6776         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6777         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6778
6779         /* Controls for GPIO pins, assuming they are configured as outputs */
6780         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6781         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6782         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6783         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6784
6785         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6786          * is ambigious as to which NID is which; testing on laptops which
6787          * make this output available should provide clarification.
6788          */
6789         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6790         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6791
6792         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6793          * this output to turn on an external amplifier.
6794          */
6795         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6796         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6797
6798         { } /* end */
6799 };
6800 static struct hda_verb alc260_test_init_verbs[] = {
6801         /* Enable all GPIOs as outputs with an initial value of 0 */
6802         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6803         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6804         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6805
6806         /* Enable retasking pins as output, initially without power amp */
6807         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6808         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6809         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6810         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6811         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6812         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6813
6814         /* Disable digital (SPDIF) pins initially, but users can enable
6815          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6816          * payload also sets the generation to 0, output to be in "consumer"
6817          * PCM format, copyright asserted, no pre-emphasis and no validity
6818          * control.
6819          */
6820         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6821         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6822
6823         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6824          * OUT1 sum bus when acting as an output.
6825          */
6826         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6827         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6828         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6829         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6830
6831         /* Start with output sum widgets muted and their output gains at min */
6832         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6833         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6834         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6835         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6836         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6837         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6838         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6839         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6840         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6841
6842         /* Unmute retasking pin widget output buffers since the default
6843          * state appears to be output.  As the pin mode is changed by the
6844          * user the pin mode control will take care of enabling the pin's
6845          * input/output buffers as needed.
6846          */
6847         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6848         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6849         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6850         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6851         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6852         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6853         /* Also unmute the mono-out pin widget */
6854         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6855
6856         /* Mute capture amp left and right */
6857         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6858         /* Set ADC connection select to match default mixer setting (mic1
6859          * pin)
6860          */
6861         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6862
6863         /* Do the same for the second ADC: mute capture input amp and
6864          * set ADC connection to mic1 pin
6865          */
6866         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6867         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6868
6869         /* Mute all inputs to mixer widget (even unconnected ones) */
6870         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6871         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6872         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6873         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6874         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6875         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6876         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6877         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6878
6879         { }
6880 };
6881 #endif
6882
6883 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6884 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6885
6886 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6887 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6888
6889 /*
6890  * for BIOS auto-configuration
6891  */
6892
6893 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6894                                         const char *pfx, int *vol_bits)
6895 {
6896         hda_nid_t nid_vol;
6897         unsigned long vol_val, sw_val;
6898         int err;
6899
6900         if (nid >= 0x0f && nid < 0x11) {
6901                 nid_vol = nid - 0x7;
6902                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6903                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6904         } else if (nid == 0x11) {
6905                 nid_vol = nid - 0x7;
6906                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6907                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6908         } else if (nid >= 0x12 && nid <= 0x15) {
6909                 nid_vol = 0x08;
6910                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6911                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6912         } else
6913                 return 0; /* N/A */
6914
6915         if (!(*vol_bits & (1 << nid_vol))) {
6916                 /* first control for the volume widget */
6917                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6918                 if (err < 0)
6919                         return err;
6920                 *vol_bits |= (1 << nid_vol);
6921         }
6922         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6923         if (err < 0)
6924                 return err;
6925         return 1;
6926 }
6927
6928 /* add playback controls from the parsed DAC table */
6929 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6930                                              const struct auto_pin_cfg *cfg)
6931 {
6932         hda_nid_t nid;
6933         int err;
6934         int vols = 0;
6935
6936         spec->multiout.num_dacs = 1;
6937         spec->multiout.dac_nids = spec->private_dac_nids;
6938         spec->multiout.dac_nids[0] = 0x02;
6939
6940         nid = cfg->line_out_pins[0];
6941         if (nid) {
6942                 const char *pfx;
6943                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6944                         pfx = "Master";
6945                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6946                         pfx = "Speaker";
6947                 else
6948                         pfx = "Front";
6949                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6950                 if (err < 0)
6951                         return err;
6952         }
6953
6954         nid = cfg->speaker_pins[0];
6955         if (nid) {
6956                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6957                 if (err < 0)
6958                         return err;
6959         }
6960
6961         nid = cfg->hp_pins[0];
6962         if (nid) {
6963                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6964                                                    &vols);
6965                 if (err < 0)
6966                         return err;
6967         }
6968         return 0;
6969 }
6970
6971 /* create playback/capture controls for input pins */
6972 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6973                                                 const struct auto_pin_cfg *cfg)
6974 {
6975         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6976 }
6977
6978 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6979                                               hda_nid_t nid, int pin_type,
6980                                               int sel_idx)
6981 {
6982         alc_set_pin_output(codec, nid, pin_type);
6983         /* need the manual connection? */
6984         if (nid >= 0x12) {
6985                 int idx = nid - 0x12;
6986                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6987                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6988         }
6989 }
6990
6991 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6992 {
6993         struct alc_spec *spec = codec->spec;
6994         hda_nid_t nid;
6995
6996         nid = spec->autocfg.line_out_pins[0];
6997         if (nid) {
6998                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6999                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
7000         }
7001
7002         nid = spec->autocfg.speaker_pins[0];
7003         if (nid)
7004                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
7005
7006         nid = spec->autocfg.hp_pins[0];
7007         if (nid)
7008                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
7009 }
7010
7011 #define ALC260_PIN_CD_NID               0x16
7012 static void alc260_auto_init_analog_input(struct hda_codec *codec)
7013 {
7014         struct alc_spec *spec = codec->spec;
7015         struct auto_pin_cfg *cfg = &spec->autocfg;
7016         int i;
7017
7018         for (i = 0; i < cfg->num_inputs; i++) {
7019                 hda_nid_t nid = cfg->inputs[i].pin;
7020                 if (nid >= 0x12) {
7021                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
7022                         if (nid != ALC260_PIN_CD_NID &&
7023                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
7024                                 snd_hda_codec_write(codec, nid, 0,
7025                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7026                                                     AMP_OUT_MUTE);
7027                 }
7028         }
7029 }
7030
7031 #define alc260_auto_init_input_src      alc880_auto_init_input_src
7032
7033 /*
7034  * generic initialization of ADC, input mixers and output mixers
7035  */
7036 static struct hda_verb alc260_volume_init_verbs[] = {
7037         /*
7038          * Unmute ADC0-1 and set the default input to mic-in
7039          */
7040         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7041         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7042         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7043         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7044
7045         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7046          * mixer widget
7047          * Note: PASD motherboards uses the Line In 2 as the input for
7048          * front panel mic (mic 2)
7049          */
7050         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7051         /* mute analog inputs */
7052         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7053         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7054         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7055         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7056         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7057
7058         /*
7059          * Set up output mixers (0x08 - 0x0a)
7060          */
7061         /* set vol=0 to output mixers */
7062         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7063         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7064         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7065         /* set up input amps for analog loopback */
7066         /* Amp Indices: DAC = 0, mixer = 1 */
7067         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7068         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7069         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7070         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7071         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7072         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7073
7074         { }
7075 };
7076
7077 static int alc260_parse_auto_config(struct hda_codec *codec)
7078 {
7079         struct alc_spec *spec = codec->spec;
7080         int err;
7081         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
7082
7083         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7084                                            alc260_ignore);
7085         if (err < 0)
7086                 return err;
7087         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7088         if (err < 0)
7089                 return err;
7090         if (!spec->kctls.list)
7091                 return 0; /* can't find valid BIOS pin config */
7092         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7093         if (err < 0)
7094                 return err;
7095
7096         spec->multiout.max_channels = 2;
7097
7098         if (spec->autocfg.dig_outs)
7099                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7100         if (spec->kctls.list)
7101                 add_mixer(spec, spec->kctls.list);
7102
7103         add_verb(spec, alc260_volume_init_verbs);
7104
7105         spec->num_mux_defs = 1;
7106         spec->input_mux = &spec->private_imux[0];
7107
7108         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7109
7110         return 1;
7111 }
7112
7113 /* additional initialization for auto-configuration model */
7114 static void alc260_auto_init(struct hda_codec *codec)
7115 {
7116         struct alc_spec *spec = codec->spec;
7117         alc260_auto_init_multi_out(codec);
7118         alc260_auto_init_analog_input(codec);
7119         alc260_auto_init_input_src(codec);
7120         alc_auto_init_digital(codec);
7121         if (spec->unsol_event)
7122                 alc_inithook(codec);
7123 }
7124
7125 #ifdef CONFIG_SND_HDA_POWER_SAVE
7126 static struct hda_amp_list alc260_loopbacks[] = {
7127         { 0x07, HDA_INPUT, 0 },
7128         { 0x07, HDA_INPUT, 1 },
7129         { 0x07, HDA_INPUT, 2 },
7130         { 0x07, HDA_INPUT, 3 },
7131         { 0x07, HDA_INPUT, 4 },
7132         { } /* end */
7133 };
7134 #endif
7135
7136 /*
7137  * Pin config fixes
7138  */
7139 enum {
7140         PINFIX_HP_DC5750,
7141 };
7142
7143 static const struct alc_fixup alc260_fixups[] = {
7144         [PINFIX_HP_DC5750] = {
7145                 .type = ALC_FIXUP_PINS,
7146                 .v.pins = (const struct alc_pincfg[]) {
7147                         { 0x11, 0x90130110 }, /* speaker */
7148                         { }
7149                 }
7150         },
7151 };
7152
7153 static struct snd_pci_quirk alc260_fixup_tbl[] = {
7154         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7155         {}
7156 };
7157
7158 /*
7159  * ALC260 configurations
7160  */
7161 static const char * const alc260_models[ALC260_MODEL_LAST] = {
7162         [ALC260_BASIC]          = "basic",
7163         [ALC260_HP]             = "hp",
7164         [ALC260_HP_3013]        = "hp-3013",
7165         [ALC260_HP_DC7600]      = "hp-dc7600",
7166         [ALC260_FUJITSU_S702X]  = "fujitsu",
7167         [ALC260_ACER]           = "acer",
7168         [ALC260_WILL]           = "will",
7169         [ALC260_REPLACER_672V]  = "replacer",
7170         [ALC260_FAVORIT100]     = "favorit100",
7171 #ifdef CONFIG_SND_DEBUG
7172         [ALC260_TEST]           = "test",
7173 #endif
7174         [ALC260_AUTO]           = "auto",
7175 };
7176
7177 static struct snd_pci_quirk alc260_cfg_tbl[] = {
7178         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7179         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7180         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7181         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7182         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7183         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7184         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7185         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7186         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7187         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7188         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7189         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7190         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7191         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7192         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7193         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7194         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7195         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7196         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7197         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7198         {}
7199 };
7200
7201 static struct alc_config_preset alc260_presets[] = {
7202         [ALC260_BASIC] = {
7203                 .mixers = { alc260_base_output_mixer,
7204                             alc260_input_mixer },
7205                 .init_verbs = { alc260_init_verbs },
7206                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7207                 .dac_nids = alc260_dac_nids,
7208                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7209                 .adc_nids = alc260_dual_adc_nids,
7210                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7211                 .channel_mode = alc260_modes,
7212                 .input_mux = &alc260_capture_source,
7213         },
7214         [ALC260_HP] = {
7215                 .mixers = { alc260_hp_output_mixer,
7216                             alc260_input_mixer },
7217                 .init_verbs = { alc260_init_verbs,
7218                                 alc260_hp_unsol_verbs },
7219                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7220                 .dac_nids = alc260_dac_nids,
7221                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7222                 .adc_nids = alc260_adc_nids_alt,
7223                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7224                 .channel_mode = alc260_modes,
7225                 .input_mux = &alc260_capture_source,
7226                 .unsol_event = alc260_hp_unsol_event,
7227                 .init_hook = alc260_hp_automute,
7228         },
7229         [ALC260_HP_DC7600] = {
7230                 .mixers = { alc260_hp_dc7600_mixer,
7231                             alc260_input_mixer },
7232                 .init_verbs = { alc260_init_verbs,
7233                                 alc260_hp_dc7600_verbs },
7234                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7235                 .dac_nids = alc260_dac_nids,
7236                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7237                 .adc_nids = alc260_adc_nids_alt,
7238                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7239                 .channel_mode = alc260_modes,
7240                 .input_mux = &alc260_capture_source,
7241                 .unsol_event = alc260_hp_3012_unsol_event,
7242                 .init_hook = alc260_hp_3012_automute,
7243         },
7244         [ALC260_HP_3013] = {
7245                 .mixers = { alc260_hp_3013_mixer,
7246                             alc260_input_mixer },
7247                 .init_verbs = { alc260_hp_3013_init_verbs,
7248                                 alc260_hp_3013_unsol_verbs },
7249                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7250                 .dac_nids = alc260_dac_nids,
7251                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7252                 .adc_nids = alc260_adc_nids_alt,
7253                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7254                 .channel_mode = alc260_modes,
7255                 .input_mux = &alc260_capture_source,
7256                 .unsol_event = alc260_hp_3013_unsol_event,
7257                 .init_hook = alc260_hp_3013_automute,
7258         },
7259         [ALC260_FUJITSU_S702X] = {
7260                 .mixers = { alc260_fujitsu_mixer },
7261                 .init_verbs = { alc260_fujitsu_init_verbs },
7262                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7263                 .dac_nids = alc260_dac_nids,
7264                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7265                 .adc_nids = alc260_dual_adc_nids,
7266                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7267                 .channel_mode = alc260_modes,
7268                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7269                 .input_mux = alc260_fujitsu_capture_sources,
7270         },
7271         [ALC260_ACER] = {
7272                 .mixers = { alc260_acer_mixer },
7273                 .init_verbs = { alc260_acer_init_verbs },
7274                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7275                 .dac_nids = alc260_dac_nids,
7276                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7277                 .adc_nids = alc260_dual_adc_nids,
7278                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7279                 .channel_mode = alc260_modes,
7280                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7281                 .input_mux = alc260_acer_capture_sources,
7282         },
7283         [ALC260_FAVORIT100] = {
7284                 .mixers = { alc260_favorit100_mixer },
7285                 .init_verbs = { alc260_favorit100_init_verbs },
7286                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7287                 .dac_nids = alc260_dac_nids,
7288                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7289                 .adc_nids = alc260_dual_adc_nids,
7290                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7291                 .channel_mode = alc260_modes,
7292                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7293                 .input_mux = alc260_favorit100_capture_sources,
7294         },
7295         [ALC260_WILL] = {
7296                 .mixers = { alc260_will_mixer },
7297                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7298                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7299                 .dac_nids = alc260_dac_nids,
7300                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7301                 .adc_nids = alc260_adc_nids,
7302                 .dig_out_nid = ALC260_DIGOUT_NID,
7303                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7304                 .channel_mode = alc260_modes,
7305                 .input_mux = &alc260_capture_source,
7306         },
7307         [ALC260_REPLACER_672V] = {
7308                 .mixers = { alc260_replacer_672v_mixer },
7309                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7310                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7311                 .dac_nids = alc260_dac_nids,
7312                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7313                 .adc_nids = alc260_adc_nids,
7314                 .dig_out_nid = ALC260_DIGOUT_NID,
7315                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7316                 .channel_mode = alc260_modes,
7317                 .input_mux = &alc260_capture_source,
7318                 .unsol_event = alc260_replacer_672v_unsol_event,
7319                 .init_hook = alc260_replacer_672v_automute,
7320         },
7321 #ifdef CONFIG_SND_DEBUG
7322         [ALC260_TEST] = {
7323                 .mixers = { alc260_test_mixer },
7324                 .init_verbs = { alc260_test_init_verbs },
7325                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7326                 .dac_nids = alc260_test_dac_nids,
7327                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7328                 .adc_nids = alc260_test_adc_nids,
7329                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7330                 .channel_mode = alc260_modes,
7331                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7332                 .input_mux = alc260_test_capture_sources,
7333         },
7334 #endif
7335 };
7336
7337 static int patch_alc260(struct hda_codec *codec)
7338 {
7339         struct alc_spec *spec;
7340         int err, board_config;
7341
7342         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7343         if (spec == NULL)
7344                 return -ENOMEM;
7345
7346         codec->spec = spec;
7347
7348         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7349                                                   alc260_models,
7350                                                   alc260_cfg_tbl);
7351         if (board_config < 0) {
7352                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7353                            codec->chip_name);
7354                 board_config = ALC260_AUTO;
7355         }
7356
7357         if (board_config == ALC260_AUTO) {
7358                 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
7359                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
7360         }
7361
7362         if (board_config == ALC260_AUTO) {
7363                 /* automatic parse from the BIOS config */
7364                 err = alc260_parse_auto_config(codec);
7365                 if (err < 0) {
7366                         alc_free(codec);
7367                         return err;
7368                 } else if (!err) {
7369                         printk(KERN_INFO
7370                                "hda_codec: Cannot set up configuration "
7371                                "from BIOS.  Using base mode...\n");
7372                         board_config = ALC260_BASIC;
7373                 }
7374         }
7375
7376         err = snd_hda_attach_beep_device(codec, 0x1);
7377         if (err < 0) {
7378                 alc_free(codec);
7379                 return err;
7380         }
7381
7382         if (board_config != ALC260_AUTO)
7383                 setup_preset(codec, &alc260_presets[board_config]);
7384
7385         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7386         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7387         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7388
7389         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7390         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7391
7392         if (!spec->adc_nids && spec->input_mux) {
7393                 /* check whether NID 0x04 is valid */
7394                 unsigned int wcap = get_wcaps(codec, 0x04);
7395                 wcap = get_wcaps_type(wcap);
7396                 /* get type */
7397                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7398                         spec->adc_nids = alc260_adc_nids_alt;
7399                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7400                 } else {
7401                         spec->adc_nids = alc260_adc_nids;
7402                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7403                 }
7404         }
7405         set_capture_mixer(codec);
7406         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7407
7408         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7409
7410         spec->vmaster_nid = 0x08;
7411
7412         codec->patch_ops = alc_patch_ops;
7413         if (board_config == ALC260_AUTO)
7414                 spec->init_hook = alc260_auto_init;
7415 #ifdef CONFIG_SND_HDA_POWER_SAVE
7416         if (!spec->loopback.amplist)
7417                 spec->loopback.amplist = alc260_loopbacks;
7418 #endif
7419
7420         return 0;
7421 }
7422
7423
7424 /*
7425  * ALC882/883/885/888/889 support
7426  *
7427  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7428  * configuration.  Each pin widget can choose any input DACs and a mixer.
7429  * Each ADC is connected from a mixer of all inputs.  This makes possible
7430  * 6-channel independent captures.
7431  *
7432  * In addition, an independent DAC for the multi-playback (not used in this
7433  * driver yet).
7434  */
7435 #define ALC882_DIGOUT_NID       0x06
7436 #define ALC882_DIGIN_NID        0x0a
7437 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7438 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7439 #define ALC1200_DIGOUT_NID      0x10
7440
7441
7442 static struct hda_channel_mode alc882_ch_modes[1] = {
7443         { 8, NULL }
7444 };
7445
7446 /* DACs */
7447 static hda_nid_t alc882_dac_nids[4] = {
7448         /* front, rear, clfe, rear_surr */
7449         0x02, 0x03, 0x04, 0x05
7450 };
7451 #define alc883_dac_nids         alc882_dac_nids
7452
7453 /* ADCs */
7454 #define alc882_adc_nids         alc880_adc_nids
7455 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7456 #define alc883_adc_nids         alc882_adc_nids_alt
7457 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7458 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7459 #define alc889_adc_nids         alc880_adc_nids
7460
7461 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7462 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7463 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7464 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7465 #define alc889_capsrc_nids      alc882_capsrc_nids
7466
7467 /* input MUX */
7468 /* FIXME: should be a matrix-type input source selection */
7469
7470 static struct hda_input_mux alc882_capture_source = {
7471         .num_items = 4,
7472         .items = {
7473                 { "Mic", 0x0 },
7474                 { "Front Mic", 0x1 },
7475                 { "Line", 0x2 },
7476                 { "CD", 0x4 },
7477         },
7478 };
7479
7480 #define alc883_capture_source   alc882_capture_source
7481
7482 static struct hda_input_mux alc889_capture_source = {
7483         .num_items = 3,
7484         .items = {
7485                 { "Front Mic", 0x0 },
7486                 { "Mic", 0x3 },
7487                 { "Line", 0x2 },
7488         },
7489 };
7490
7491 static struct hda_input_mux mb5_capture_source = {
7492         .num_items = 3,
7493         .items = {
7494                 { "Mic", 0x1 },
7495                 { "Line", 0x7 },
7496                 { "CD", 0x4 },
7497         },
7498 };
7499
7500 static struct hda_input_mux macmini3_capture_source = {
7501         .num_items = 2,
7502         .items = {
7503                 { "Line", 0x2 },
7504                 { "CD", 0x4 },
7505         },
7506 };
7507
7508 static struct hda_input_mux alc883_3stack_6ch_intel = {
7509         .num_items = 4,
7510         .items = {
7511                 { "Mic", 0x1 },
7512                 { "Front Mic", 0x0 },
7513                 { "Line", 0x2 },
7514                 { "CD", 0x4 },
7515         },
7516 };
7517
7518 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7519         .num_items = 2,
7520         .items = {
7521                 { "Mic", 0x1 },
7522                 { "Line", 0x2 },
7523         },
7524 };
7525
7526 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7527         .num_items = 4,
7528         .items = {
7529                 { "Mic", 0x0 },
7530                 { "Internal Mic", 0x1 },
7531                 { "Line", 0x2 },
7532                 { "CD", 0x4 },
7533         },
7534 };
7535
7536 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7537         .num_items = 2,
7538         .items = {
7539                 { "Mic", 0x0 },
7540                 { "Internal Mic", 0x1 },
7541         },
7542 };
7543
7544 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7545         .num_items = 3,
7546         .items = {
7547                 { "Mic", 0x0 },
7548                 { "Front Mic", 0x1 },
7549                 { "Line", 0x4 },
7550         },
7551 };
7552
7553 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7554         .num_items = 2,
7555         .items = {
7556                 { "Mic", 0x0 },
7557                 { "Line", 0x2 },
7558         },
7559 };
7560
7561 static struct hda_input_mux alc889A_mb31_capture_source = {
7562         .num_items = 2,
7563         .items = {
7564                 { "Mic", 0x0 },
7565                 /* Front Mic (0x01) unused */
7566                 { "Line", 0x2 },
7567                 /* Line 2 (0x03) unused */
7568                 /* CD (0x04) unused? */
7569         },
7570 };
7571
7572 static struct hda_input_mux alc889A_imac91_capture_source = {
7573         .num_items = 2,
7574         .items = {
7575                 { "Mic", 0x01 },
7576                 { "Line", 0x2 }, /* Not sure! */
7577         },
7578 };
7579
7580 /*
7581  * 2ch mode
7582  */
7583 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7584         { 2, NULL }
7585 };
7586
7587 /*
7588  * 2ch mode
7589  */
7590 static struct hda_verb alc882_3ST_ch2_init[] = {
7591         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7592         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7593         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7594         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7595         { } /* end */
7596 };
7597
7598 /*
7599  * 4ch mode
7600  */
7601 static struct hda_verb alc882_3ST_ch4_init[] = {
7602         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7603         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7604         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7605         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7606         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7607         { } /* end */
7608 };
7609
7610 /*
7611  * 6ch mode
7612  */
7613 static struct hda_verb alc882_3ST_ch6_init[] = {
7614         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7615         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7616         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7617         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7618         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7619         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7620         { } /* end */
7621 };
7622
7623 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7624         { 2, alc882_3ST_ch2_init },
7625         { 4, alc882_3ST_ch4_init },
7626         { 6, alc882_3ST_ch6_init },
7627 };
7628
7629 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7630
7631 /*
7632  * 2ch mode
7633  */
7634 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7635         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7636         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7637         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7638         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7639         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7640         { } /* end */
7641 };
7642
7643 /*
7644  * 4ch mode
7645  */
7646 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7647         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7648         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7649         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7650         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7651         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7652         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7653         { } /* end */
7654 };
7655
7656 /*
7657  * 6ch mode
7658  */
7659 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7660         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7661         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7662         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7663         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7664         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7665         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7666         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7667         { } /* end */
7668 };
7669
7670 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7671         { 2, alc883_3ST_ch2_clevo_init },
7672         { 4, alc883_3ST_ch4_clevo_init },
7673         { 6, alc883_3ST_ch6_clevo_init },
7674 };
7675
7676
7677 /*
7678  * 6ch mode
7679  */
7680 static struct hda_verb alc882_sixstack_ch6_init[] = {
7681         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7682         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7683         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7684         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7685         { } /* end */
7686 };
7687
7688 /*
7689  * 8ch mode
7690  */
7691 static struct hda_verb alc882_sixstack_ch8_init[] = {
7692         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7693         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7694         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7695         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7696         { } /* end */
7697 };
7698
7699 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7700         { 6, alc882_sixstack_ch6_init },
7701         { 8, alc882_sixstack_ch8_init },
7702 };
7703
7704
7705 /* Macbook Air 2,1 */
7706
7707 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7708       { 2, NULL },
7709 };
7710
7711 /*
7712  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7713  */
7714
7715 /*
7716  * 2ch mode
7717  */
7718 static struct hda_verb alc885_mbp_ch2_init[] = {
7719         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7720         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7721         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7722         { } /* end */
7723 };
7724
7725 /*
7726  * 4ch mode
7727  */
7728 static struct hda_verb alc885_mbp_ch4_init[] = {
7729         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7730         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7731         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7732         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7733         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7734         { } /* end */
7735 };
7736
7737 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7738         { 2, alc885_mbp_ch2_init },
7739         { 4, alc885_mbp_ch4_init },
7740 };
7741
7742 /*
7743  * 2ch
7744  * Speakers/Woofer/HP = Front
7745  * LineIn = Input
7746  */
7747 static struct hda_verb alc885_mb5_ch2_init[] = {
7748         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7749         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7750         { } /* end */
7751 };
7752
7753 /*
7754  * 6ch mode
7755  * Speakers/HP = Front
7756  * Woofer = LFE
7757  * LineIn = Surround
7758  */
7759 static struct hda_verb alc885_mb5_ch6_init[] = {
7760         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7761         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7762         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7763         { } /* end */
7764 };
7765
7766 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7767         { 2, alc885_mb5_ch2_init },
7768         { 6, alc885_mb5_ch6_init },
7769 };
7770
7771 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7772
7773 /*
7774  * 2ch mode
7775  */
7776 static struct hda_verb alc883_4ST_ch2_init[] = {
7777         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7778         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7779         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7780         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7781         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7782         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7783         { } /* end */
7784 };
7785
7786 /*
7787  * 4ch mode
7788  */
7789 static struct hda_verb alc883_4ST_ch4_init[] = {
7790         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7791         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7792         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7793         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7794         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7795         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7796         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7797         { } /* end */
7798 };
7799
7800 /*
7801  * 6ch mode
7802  */
7803 static struct hda_verb alc883_4ST_ch6_init[] = {
7804         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7805         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7806         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7807         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7808         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7809         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7810         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7811         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7812         { } /* end */
7813 };
7814
7815 /*
7816  * 8ch mode
7817  */
7818 static struct hda_verb alc883_4ST_ch8_init[] = {
7819         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7820         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7821         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7822         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7823         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7824         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7825         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7826         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7827         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7828         { } /* end */
7829 };
7830
7831 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7832         { 2, alc883_4ST_ch2_init },
7833         { 4, alc883_4ST_ch4_init },
7834         { 6, alc883_4ST_ch6_init },
7835         { 8, alc883_4ST_ch8_init },
7836 };
7837
7838
7839 /*
7840  * 2ch mode
7841  */
7842 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7843         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7844         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7845         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7846         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7847         { } /* end */
7848 };
7849
7850 /*
7851  * 4ch mode
7852  */
7853 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7854         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7855         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7856         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7857         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7858         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7859         { } /* end */
7860 };
7861
7862 /*
7863  * 6ch mode
7864  */
7865 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7866         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7867         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7868         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7869         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7870         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7871         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7872         { } /* end */
7873 };
7874
7875 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7876         { 2, alc883_3ST_ch2_intel_init },
7877         { 4, alc883_3ST_ch4_intel_init },
7878         { 6, alc883_3ST_ch6_intel_init },
7879 };
7880
7881 /*
7882  * 2ch mode
7883  */
7884 static struct hda_verb alc889_ch2_intel_init[] = {
7885         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7886         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7887         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7888         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7889         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7890         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7891         { } /* end */
7892 };
7893
7894 /*
7895  * 6ch mode
7896  */
7897 static struct hda_verb alc889_ch6_intel_init[] = {
7898         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7899         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7900         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7901         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7902         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7903         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7904         { } /* end */
7905 };
7906
7907 /*
7908  * 8ch mode
7909  */
7910 static struct hda_verb alc889_ch8_intel_init[] = {
7911         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7912         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7913         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7914         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7915         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7916         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7917         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7918         { } /* end */
7919 };
7920
7921 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7922         { 2, alc889_ch2_intel_init },
7923         { 6, alc889_ch6_intel_init },
7924         { 8, alc889_ch8_intel_init },
7925 };
7926
7927 /*
7928  * 6ch mode
7929  */
7930 static struct hda_verb alc883_sixstack_ch6_init[] = {
7931         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7932         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7933         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7934         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7935         { } /* end */
7936 };
7937
7938 /*
7939  * 8ch mode
7940  */
7941 static struct hda_verb alc883_sixstack_ch8_init[] = {
7942         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7943         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7944         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7945         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7946         { } /* end */
7947 };
7948
7949 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7950         { 6, alc883_sixstack_ch6_init },
7951         { 8, alc883_sixstack_ch8_init },
7952 };
7953
7954
7955 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7956  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7957  */
7958 static struct snd_kcontrol_new alc882_base_mixer[] = {
7959         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7960         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7961         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7962         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7963         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7964         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7965         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7966         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7967         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7968         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7969         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7970         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7971         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7972         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7973         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7974         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7975         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
7976         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7977         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7978         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
7979         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7980         { } /* end */
7981 };
7982
7983 /* Macbook Air 2,1 same control for HP and internal Speaker */
7984
7985 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7986       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7987       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7988      { }
7989 };
7990
7991
7992 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7993         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7994         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7995         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7996         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7997         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7998         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7999         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8000         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8001         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8002         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
8003         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
8004         { } /* end */
8005 };
8006
8007 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
8008         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8009         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8010         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8011         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8012         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8013         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8014         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8015         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8016         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8017         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8018         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8019         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8020         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8021         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT),
8022         { } /* end */
8023 };
8024
8025 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
8026         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8027         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8028         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8029         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8030         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8031         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8032         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8033         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8034         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8035         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8036         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8037         { } /* end */
8038 };
8039
8040 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
8041         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8042         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8043         { } /* end */
8044 };
8045
8046
8047 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
8048         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8049         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8050         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8051         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8052         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8053         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8054         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8055         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8056         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8057         { } /* end */
8058 };
8059
8060 static struct snd_kcontrol_new alc882_targa_mixer[] = {
8061         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8062         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8063         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8064         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8065         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8066         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8067         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8068         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8069         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8070         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8071         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8072         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8073         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8074         { } /* end */
8075 };
8076
8077 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8078  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8079  */
8080 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8081         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8082         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8083         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8084         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8085         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8086         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8087         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8088         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8089         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8090         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8091         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8092         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8093         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8094         { } /* end */
8095 };
8096
8097 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8098         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8099         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8100         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8101         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8102         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8103         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8104         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8105         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8106         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8107         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8108         { } /* end */
8109 };
8110
8111 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
8112         {
8113                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8114                 .name = "Channel Mode",
8115                 .info = alc_ch_mode_info,
8116                 .get = alc_ch_mode_get,
8117                 .put = alc_ch_mode_put,
8118         },
8119         { } /* end */
8120 };
8121
8122 static struct hda_verb alc882_base_init_verbs[] = {
8123         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8124         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8125         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8126         /* Rear mixer */
8127         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8128         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8129         /* CLFE mixer */
8130         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8131         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8132         /* Side mixer */
8133         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8134         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8135
8136         /* Front Pin: output 0 (0x0c) */
8137         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8138         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8139         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8140         /* Rear Pin: output 1 (0x0d) */
8141         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8142         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8143         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8144         /* CLFE Pin: output 2 (0x0e) */
8145         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8146         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8147         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8148         /* Side Pin: output 3 (0x0f) */
8149         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8150         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8151         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8152         /* Mic (rear) pin: input vref at 80% */
8153         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8154         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8155         /* Front Mic pin: input vref at 80% */
8156         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8157         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8158         /* Line In pin: input */
8159         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8160         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8161         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8162         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8163         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8164         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8165         /* CD pin widget for input */
8166         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8167
8168         /* FIXME: use matrix-type input source selection */
8169         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8170         /* Input mixer2 */
8171         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8172         /* Input mixer3 */
8173         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8174         /* ADC2: mute amp left and right */
8175         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8176         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8177         /* ADC3: mute amp left and right */
8178         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8179         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8180
8181         { }
8182 };
8183
8184 static struct hda_verb alc882_adc1_init_verbs[] = {
8185         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8186         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8187         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8188         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8189         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8190         /* ADC1: mute amp left and right */
8191         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8192         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8193         { }
8194 };
8195
8196 static struct hda_verb alc882_eapd_verbs[] = {
8197         /* change to EAPD mode */
8198         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8199         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8200         { }
8201 };
8202
8203 static struct hda_verb alc889_eapd_verbs[] = {
8204         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8205         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8206         { }
8207 };
8208
8209 static struct hda_verb alc_hp15_unsol_verbs[] = {
8210         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8211         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8212         {}
8213 };
8214
8215 static struct hda_verb alc885_init_verbs[] = {
8216         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8217         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8218         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8219         /* Rear mixer */
8220         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8221         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8222         /* CLFE mixer */
8223         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8224         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8225         /* Side mixer */
8226         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8227         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8228
8229         /* Front HP Pin: output 0 (0x0c) */
8230         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8231         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8232         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8233         /* Front Pin: output 0 (0x0c) */
8234         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8235         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8236         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8237         /* Rear Pin: output 1 (0x0d) */
8238         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8239         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8240         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8241         /* CLFE Pin: output 2 (0x0e) */
8242         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8243         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8244         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8245         /* Side Pin: output 3 (0x0f) */
8246         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8247         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8248         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8249         /* Mic (rear) pin: input vref at 80% */
8250         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8251         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8252         /* Front Mic pin: input vref at 80% */
8253         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8254         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8255         /* Line In pin: input */
8256         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8257         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8258
8259         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8260         /* Input mixer1 */
8261         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8262         /* Input mixer2 */
8263         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8264         /* Input mixer3 */
8265         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8266         /* ADC2: mute amp left and right */
8267         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8268         /* ADC3: mute amp left and right */
8269         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8270
8271         { }
8272 };
8273
8274 static struct hda_verb alc885_init_input_verbs[] = {
8275         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8276         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8277         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8278         { }
8279 };
8280
8281
8282 /* Unmute Selector 24h and set the default input to front mic */
8283 static struct hda_verb alc889_init_input_verbs[] = {
8284         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8285         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8286         { }
8287 };
8288
8289
8290 #define alc883_init_verbs       alc882_base_init_verbs
8291
8292 /* Mac Pro test */
8293 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8294         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8295         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8296         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8297         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8298         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8299         /* FIXME: this looks suspicious...
8300         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8301         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8302         */
8303         { } /* end */
8304 };
8305
8306 static struct hda_verb alc882_macpro_init_verbs[] = {
8307         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8308         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8309         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8310         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8311         /* Front Pin: output 0 (0x0c) */
8312         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8313         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8314         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8315         /* Front Mic pin: input vref at 80% */
8316         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8317         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8318         /* Speaker:  output */
8319         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8320         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8321         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8322         /* Headphone output (output 0 - 0x0c) */
8323         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8324         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8325         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8326
8327         /* FIXME: use matrix-type input source selection */
8328         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8329         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8330         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8331         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8332         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8333         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8334         /* Input mixer2 */
8335         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8336         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8337         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8338         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8339         /* Input mixer3 */
8340         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8341         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8342         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8343         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8344         /* ADC1: mute amp left and right */
8345         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8346         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8347         /* ADC2: mute amp left and right */
8348         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8349         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8350         /* ADC3: mute amp left and right */
8351         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8352         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8353
8354         { }
8355 };
8356
8357 /* Macbook 5,1 */
8358 static struct hda_verb alc885_mb5_init_verbs[] = {
8359         /* DACs */
8360         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8361         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8362         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8363         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8364         /* Front mixer */
8365         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8366         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8367         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8368         /* Surround mixer */
8369         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8370         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8371         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8372         /* LFE mixer */
8373         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8374         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8375         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8376         /* HP mixer */
8377         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8378         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8379         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8380         /* Front Pin (0x0c) */
8381         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8382         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8383         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8384         /* LFE Pin (0x0e) */
8385         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8386         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8387         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8388         /* HP Pin (0x0f) */
8389         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8390         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8391         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8392         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8393         /* Front Mic pin: input vref at 80% */
8394         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8395         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8396         /* Line In pin */
8397         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8398         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8399
8400         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8401         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8402         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8403         { }
8404 };
8405
8406 /* Macmini 3,1 */
8407 static struct hda_verb alc885_macmini3_init_verbs[] = {
8408         /* DACs */
8409         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8410         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8411         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8412         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8413         /* Front mixer */
8414         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8415         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8416         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8417         /* Surround mixer */
8418         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8419         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8420         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8421         /* LFE mixer */
8422         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8423         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8424         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8425         /* HP mixer */
8426         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8427         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8428         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8429         /* Front Pin (0x0c) */
8430         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8431         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8432         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8433         /* LFE Pin (0x0e) */
8434         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8435         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8436         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8437         /* HP Pin (0x0f) */
8438         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8439         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8440         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8441         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8442         /* Line In pin */
8443         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8444         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8445
8446         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8447         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8448         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8449         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8450         { }
8451 };
8452
8453
8454 static struct hda_verb alc885_mba21_init_verbs[] = {
8455         /*Internal and HP Speaker Mixer*/
8456         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8457         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8458         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8459         /*Internal Speaker Pin (0x0c)*/
8460         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8461         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8462         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8463         /* HP Pin: output 0 (0x0e) */
8464         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8465         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8466         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8467         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8468         /* Line in (is hp when jack connected)*/
8469         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8470         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8471
8472         { }
8473  };
8474
8475
8476 /* Macbook Pro rev3 */
8477 static struct hda_verb alc885_mbp3_init_verbs[] = {
8478         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8479         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8480         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8481         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8482         /* Rear mixer */
8483         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8484         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8485         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8486         /* HP mixer */
8487         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8488         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8489         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8490         /* Front Pin: output 0 (0x0c) */
8491         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8492         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8493         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8494         /* HP Pin: output 0 (0x0e) */
8495         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8496         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8497         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8498         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8499         /* Mic (rear) pin: input vref at 80% */
8500         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8501         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8502         /* Front Mic pin: input vref at 80% */
8503         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8504         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8505         /* Line In pin: use output 1 when in LineOut mode */
8506         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8507         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8508         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8509
8510         /* FIXME: use matrix-type input source selection */
8511         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8512         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8513         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8514         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8515         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8516         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8517         /* Input mixer2 */
8518         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8519         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8520         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8521         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8522         /* Input mixer3 */
8523         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8524         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8525         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8526         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8527         /* ADC1: mute amp left and right */
8528         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8529         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8530         /* ADC2: mute amp left and right */
8531         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8532         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8533         /* ADC3: mute amp left and right */
8534         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8535         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8536
8537         { }
8538 };
8539
8540 /* iMac 9,1 */
8541 static struct hda_verb alc885_imac91_init_verbs[] = {
8542         /* Internal Speaker Pin (0x0c) */
8543         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8544         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8545         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8546         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8547         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8548         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8549         /* HP Pin: Rear */
8550         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8551         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8552         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8553         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8554         /* Line in Rear */
8555         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8556         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8557         /* Front Mic pin: input vref at 80% */
8558         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8559         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8560         /* Rear mixer */
8561         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8562         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8563         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8564         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8565         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8566         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8567         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8568         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8569         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8570         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8571         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8572         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8573         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8574         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8575         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8576         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8577         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8578         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8579         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8580         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8581         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8582         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8583         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8584         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8585         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8586         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8587         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8588         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8589         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8590         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8591         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8592         { }
8593 };
8594
8595 /* iMac 24 mixer. */
8596 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8597         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8598         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8599         { } /* end */
8600 };
8601
8602 /* iMac 24 init verbs. */
8603 static struct hda_verb alc885_imac24_init_verbs[] = {
8604         /* Internal speakers: output 0 (0x0c) */
8605         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8606         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8607         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8608         /* Internal speakers: output 0 (0x0c) */
8609         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8610         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8611         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8612         /* Headphone: output 0 (0x0c) */
8613         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8614         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8615         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8616         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8617         /* Front Mic: input vref at 80% */
8618         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8619         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8620         { }
8621 };
8622
8623 /* Toggle speaker-output according to the hp-jack state */
8624 static void alc885_imac24_setup(struct hda_codec *codec)
8625 {
8626         struct alc_spec *spec = codec->spec;
8627
8628         spec->autocfg.hp_pins[0] = 0x14;
8629         spec->autocfg.speaker_pins[0] = 0x18;
8630         spec->autocfg.speaker_pins[1] = 0x1a;
8631 }
8632
8633 #define alc885_mb5_setup        alc885_imac24_setup
8634 #define alc885_macmini3_setup   alc885_imac24_setup
8635
8636 /* Macbook Air 2,1 */
8637 static void alc885_mba21_setup(struct hda_codec *codec)
8638 {
8639        struct alc_spec *spec = codec->spec;
8640
8641        spec->autocfg.hp_pins[0] = 0x14;
8642        spec->autocfg.speaker_pins[0] = 0x18;
8643 }
8644
8645
8646
8647 static void alc885_mbp3_setup(struct hda_codec *codec)
8648 {
8649         struct alc_spec *spec = codec->spec;
8650
8651         spec->autocfg.hp_pins[0] = 0x15;
8652         spec->autocfg.speaker_pins[0] = 0x14;
8653 }
8654
8655 static void alc885_imac91_setup(struct hda_codec *codec)
8656 {
8657         struct alc_spec *spec = codec->spec;
8658
8659         spec->autocfg.hp_pins[0] = 0x14;
8660         spec->autocfg.speaker_pins[0] = 0x18;
8661         spec->autocfg.speaker_pins[1] = 0x1a;
8662 }
8663
8664 static struct hda_verb alc882_targa_verbs[] = {
8665         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8666         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8667
8668         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8669         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8670
8671         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8672         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8673         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8674
8675         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8676         { } /* end */
8677 };
8678
8679 /* toggle speaker-output according to the hp-jack state */
8680 static void alc882_targa_automute(struct hda_codec *codec)
8681 {
8682         struct alc_spec *spec = codec->spec;
8683         alc_automute_amp(codec);
8684         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8685                                   spec->jack_present ? 1 : 3);
8686 }
8687
8688 static void alc882_targa_setup(struct hda_codec *codec)
8689 {
8690         struct alc_spec *spec = codec->spec;
8691
8692         spec->autocfg.hp_pins[0] = 0x14;
8693         spec->autocfg.speaker_pins[0] = 0x1b;
8694 }
8695
8696 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8697 {
8698         if ((res >> 26) == ALC880_HP_EVENT)
8699                 alc882_targa_automute(codec);
8700 }
8701
8702 static struct hda_verb alc882_asus_a7j_verbs[] = {
8703         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8704         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8705
8706         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8707         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8708         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8709
8710         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8711         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8712         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8713
8714         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8715         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8716         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8717         { } /* end */
8718 };
8719
8720 static struct hda_verb alc882_asus_a7m_verbs[] = {
8721         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8722         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8723
8724         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8725         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8726         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8727
8728         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8729         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8730         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8731
8732         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8733         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8734         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8735         { } /* end */
8736 };
8737
8738 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8739 {
8740         unsigned int gpiostate, gpiomask, gpiodir;
8741
8742         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8743                                        AC_VERB_GET_GPIO_DATA, 0);
8744
8745         if (!muted)
8746                 gpiostate |= (1 << pin);
8747         else
8748                 gpiostate &= ~(1 << pin);
8749
8750         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8751                                       AC_VERB_GET_GPIO_MASK, 0);
8752         gpiomask |= (1 << pin);
8753
8754         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8755                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8756         gpiodir |= (1 << pin);
8757
8758
8759         snd_hda_codec_write(codec, codec->afg, 0,
8760                             AC_VERB_SET_GPIO_MASK, gpiomask);
8761         snd_hda_codec_write(codec, codec->afg, 0,
8762                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8763
8764         msleep(1);
8765
8766         snd_hda_codec_write(codec, codec->afg, 0,
8767                             AC_VERB_SET_GPIO_DATA, gpiostate);
8768 }
8769
8770 /* set up GPIO at initialization */
8771 static void alc885_macpro_init_hook(struct hda_codec *codec)
8772 {
8773         alc882_gpio_mute(codec, 0, 0);
8774         alc882_gpio_mute(codec, 1, 0);
8775 }
8776
8777 /* set up GPIO and update auto-muting at initialization */
8778 static void alc885_imac24_init_hook(struct hda_codec *codec)
8779 {
8780         alc885_macpro_init_hook(codec);
8781         alc_automute_amp(codec);
8782 }
8783
8784 /*
8785  * generic initialization of ADC, input mixers and output mixers
8786  */
8787 static struct hda_verb alc883_auto_init_verbs[] = {
8788         /*
8789          * Unmute ADC0-2 and set the default input to mic-in
8790          */
8791         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8792         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8793         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8794         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8795
8796         /*
8797          * Set up output mixers (0x0c - 0x0f)
8798          */
8799         /* set vol=0 to output mixers */
8800         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8801         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8802         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8803         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8804         /* set up input amps for analog loopback */
8805         /* Amp Indices: DAC = 0, mixer = 1 */
8806         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8807         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8808         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8809         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8810         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8811         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8812         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8813         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8814         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8815         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8816
8817         /* FIXME: use matrix-type input source selection */
8818         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8819         /* Input mixer2 */
8820         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8821         /* Input mixer3 */
8822         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8823         { }
8824 };
8825
8826 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8827 static struct hda_verb alc889A_mb31_ch2_init[] = {
8828         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8829         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8830         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8831         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8832         { } /* end */
8833 };
8834
8835 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8836 static struct hda_verb alc889A_mb31_ch4_init[] = {
8837         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8838         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8839         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8840         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8841         { } /* end */
8842 };
8843
8844 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8845 static struct hda_verb alc889A_mb31_ch5_init[] = {
8846         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8847         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8848         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8849         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8850         { } /* end */
8851 };
8852
8853 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8854 static struct hda_verb alc889A_mb31_ch6_init[] = {
8855         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8856         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8857         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8858         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8859         { } /* end */
8860 };
8861
8862 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8863         { 2, alc889A_mb31_ch2_init },
8864         { 4, alc889A_mb31_ch4_init },
8865         { 5, alc889A_mb31_ch5_init },
8866         { 6, alc889A_mb31_ch6_init },
8867 };
8868
8869 static struct hda_verb alc883_medion_eapd_verbs[] = {
8870         /* eanable EAPD on medion laptop */
8871         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8872         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8873         { }
8874 };
8875
8876 #define alc883_base_mixer       alc882_base_mixer
8877
8878 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8879         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8880         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8881         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8882         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8883         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8884         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8885         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8886         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8887         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8888         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8889         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8890         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8891         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8892         { } /* end */
8893 };
8894
8895 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8896         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8897         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8898         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8899         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8900         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8901         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8902         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8903         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8904         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8905         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8906         { } /* end */
8907 };
8908
8909 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8910         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8911         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8912         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8913         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8914         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8915         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8916         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8917         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8918         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8919         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8920         { } /* end */
8921 };
8922
8923 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8924         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8925         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8926         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8927         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8928         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8929         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8930         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8931         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8932         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8933         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8934         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8935         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8936         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8937         { } /* end */
8938 };
8939
8940 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8941         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8942         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8943         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8944         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8945         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8946         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8947         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8948         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8949         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8950         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8951         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8952         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8953         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8954         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8955         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8956         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8957         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8958         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8959         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8960         { } /* end */
8961 };
8962
8963 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8964         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8965         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8966         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8967         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8968         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8969                               HDA_OUTPUT),
8970         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8971         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8972         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8973         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8974         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8975         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8976         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8977         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8978         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8979         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
8980         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8981         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8982         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
8983         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8984         { } /* end */
8985 };
8986
8987 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8988         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8989         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8990         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8991         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8992         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8993                               HDA_OUTPUT),
8994         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8995         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8996         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8997         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8998         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8999         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9000         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9001         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9002         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
9003         HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT),
9004         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
9005         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9006         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9007         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9008         { } /* end */
9009 };
9010
9011 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
9012         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9013         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9014         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9015         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9016         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9017         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9018         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9019         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9020         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9021         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9022         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9023         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9024         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9025         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9026         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9027         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9028         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9029         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9030         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9031         { } /* end */
9032 };
9033
9034 static struct snd_kcontrol_new alc883_targa_mixer[] = {
9035         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9036         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9037         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9038         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9039         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9040         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9041         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9042         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9043         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9044         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9045         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9046         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9047         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9048         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9049         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9050         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9051         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9052         { } /* end */
9053 };
9054
9055 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
9056         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9057         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9058         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9059         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9060         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9061         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9062         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9063         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9064         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9065         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9066         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9067         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9068         { } /* end */
9069 };
9070
9071 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
9072         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9073         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9074         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9075         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9076         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9077         { } /* end */
9078 };
9079
9080 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9081         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9082         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9083         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9084         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9085         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9086         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9087         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9088         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9089         { } /* end */
9090 };
9091
9092 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9093         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9094         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9095         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9096         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9097         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9098         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9099         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9100         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9101         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9102         { } /* end */
9103 };
9104
9105 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9106         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9107         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9108         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9109         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9110         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9111         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9112         { } /* end */
9113 };
9114
9115 static struct hda_verb alc883_medion_wim2160_verbs[] = {
9116         /* Unmute front mixer */
9117         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9118         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9119
9120         /* Set speaker pin to front mixer */
9121         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9122
9123         /* Init headphone pin */
9124         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9125         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9126         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9127         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9128
9129         { } /* end */
9130 };
9131
9132 /* toggle speaker-output according to the hp-jack state */
9133 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9134 {
9135         struct alc_spec *spec = codec->spec;
9136
9137         spec->autocfg.hp_pins[0] = 0x1a;
9138         spec->autocfg.speaker_pins[0] = 0x15;
9139 }
9140
9141 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9142         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9143         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9144         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9145         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9146         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9147         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9148         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9149         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9150         { } /* end */
9151 };
9152
9153 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9154         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9155         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9156         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9157         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9158         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9159         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9160         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9161         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9162         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9163         { } /* end */
9164 };
9165
9166 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9167         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9168         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9169         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9170         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9171         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9172                                                 0x0d, 1, 0x0, HDA_OUTPUT),
9173         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9174         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9175         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9176         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9177         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9178         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9179         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9180         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9181         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9182         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9183         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9184         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9185         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9186         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9187         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9188         { } /* end */
9189 };
9190
9191 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9192         /* Output mixers */
9193         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9194         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9195         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9196         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9197         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9198                 HDA_OUTPUT),
9199         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9200         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9201         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9202         /* Output switches */
9203         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9204         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9205         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9206         /* Boost mixers */
9207         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
9208         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
9209         /* Input mixers */
9210         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9211         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9212         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9213         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9214         { } /* end */
9215 };
9216
9217 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9218         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9219         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9220         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9221         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9222         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9223         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9224         { } /* end */
9225 };
9226
9227 static struct hda_bind_ctls alc883_bind_cap_vol = {
9228         .ops = &snd_hda_bind_vol,
9229         .values = {
9230                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9231                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9232                 0
9233         },
9234 };
9235
9236 static struct hda_bind_ctls alc883_bind_cap_switch = {
9237         .ops = &snd_hda_bind_sw,
9238         .values = {
9239                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9240                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9241                 0
9242         },
9243 };
9244
9245 static struct snd_kcontrol_new alc883_asus_eee1601_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_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9249         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9250         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9251         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9252         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9253         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9254         { } /* end */
9255 };
9256
9257 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9258         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9259         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9260         {
9261                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9262                 /* .name = "Capture Source", */
9263                 .name = "Input Source",
9264                 .count = 1,
9265                 .info = alc_mux_enum_info,
9266                 .get = alc_mux_enum_get,
9267                 .put = alc_mux_enum_put,
9268         },
9269         { } /* end */
9270 };
9271
9272 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9273         {
9274                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9275                 .name = "Channel Mode",
9276                 .info = alc_ch_mode_info,
9277                 .get = alc_ch_mode_get,
9278                 .put = alc_ch_mode_put,
9279         },
9280         { } /* end */
9281 };
9282
9283 /* toggle speaker-output according to the hp-jack state */
9284 static void alc883_mitac_setup(struct hda_codec *codec)
9285 {
9286         struct alc_spec *spec = codec->spec;
9287
9288         spec->autocfg.hp_pins[0] = 0x15;
9289         spec->autocfg.speaker_pins[0] = 0x14;
9290         spec->autocfg.speaker_pins[1] = 0x17;
9291 }
9292
9293 static struct hda_verb alc883_mitac_verbs[] = {
9294         /* HP */
9295         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9296         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9297         /* Subwoofer */
9298         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9299         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9300
9301         /* enable unsolicited event */
9302         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9303         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9304
9305         { } /* end */
9306 };
9307
9308 static struct hda_verb alc883_clevo_m540r_verbs[] = {
9309         /* HP */
9310         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9311         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9312         /* Int speaker */
9313         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9314
9315         /* enable unsolicited event */
9316         /*
9317         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9318         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9319         */
9320
9321         { } /* end */
9322 };
9323
9324 static struct hda_verb alc883_clevo_m720_verbs[] = {
9325         /* HP */
9326         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9327         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9328         /* Int speaker */
9329         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9330         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9331
9332         /* enable unsolicited event */
9333         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9334         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9335
9336         { } /* end */
9337 };
9338
9339 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9340         /* HP */
9341         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9342         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9343         /* Subwoofer */
9344         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9345         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9346
9347         /* enable unsolicited event */
9348         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9349
9350         { } /* end */
9351 };
9352
9353 static struct hda_verb alc883_targa_verbs[] = {
9354         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9355         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9356
9357         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9358         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9359
9360 /* Connect Line-Out side jack (SPDIF) to Side */
9361         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9362         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9363         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9364 /* Connect Mic jack to CLFE */
9365         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9366         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9367         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9368 /* Connect Line-in jack to Surround */
9369         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9370         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9371         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9372 /* Connect HP out jack to Front */
9373         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9374         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9375         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9376
9377         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9378
9379         { } /* end */
9380 };
9381
9382 static struct hda_verb alc883_lenovo_101e_verbs[] = {
9383         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9384         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9385         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9386         { } /* end */
9387 };
9388
9389 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9390         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9391         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9392         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9393         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9394         { } /* end */
9395 };
9396
9397 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9398         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9399         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9400         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9401         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9402         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9403         { } /* end */
9404 };
9405
9406 static struct hda_verb alc883_haier_w66_verbs[] = {
9407         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9408         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9409
9410         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9411
9412         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9413         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9414         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9415         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9416         { } /* end */
9417 };
9418
9419 static struct hda_verb alc888_lenovo_sky_verbs[] = {
9420         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9421         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9422         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9423         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9424         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9425         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9426         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9427         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9428         { } /* end */
9429 };
9430
9431 static struct hda_verb alc888_6st_dell_verbs[] = {
9432         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9433         { }
9434 };
9435
9436 static struct hda_verb alc883_vaiott_verbs[] = {
9437         /* HP */
9438         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9439         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9440
9441         /* enable unsolicited event */
9442         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9443
9444         { } /* end */
9445 };
9446
9447 static void alc888_3st_hp_setup(struct hda_codec *codec)
9448 {
9449         struct alc_spec *spec = codec->spec;
9450
9451         spec->autocfg.hp_pins[0] = 0x1b;
9452         spec->autocfg.speaker_pins[0] = 0x14;
9453         spec->autocfg.speaker_pins[1] = 0x16;
9454         spec->autocfg.speaker_pins[2] = 0x18;
9455 }
9456
9457 static struct hda_verb alc888_3st_hp_verbs[] = {
9458         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9459         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9460         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9461         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9462         { } /* end */
9463 };
9464
9465 /*
9466  * 2ch mode
9467  */
9468 static struct hda_verb alc888_3st_hp_2ch_init[] = {
9469         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9470         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9471         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9472         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9473         { } /* end */
9474 };
9475
9476 /*
9477  * 4ch mode
9478  */
9479 static struct hda_verb alc888_3st_hp_4ch_init[] = {
9480         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9481         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9482         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9483         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9484         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9485         { } /* end */
9486 };
9487
9488 /*
9489  * 6ch mode
9490  */
9491 static struct hda_verb alc888_3st_hp_6ch_init[] = {
9492         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9493         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9494         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9495         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9496         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9497         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9498         { } /* end */
9499 };
9500
9501 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9502         { 2, alc888_3st_hp_2ch_init },
9503         { 4, alc888_3st_hp_4ch_init },
9504         { 6, alc888_3st_hp_6ch_init },
9505 };
9506
9507 /* toggle front-jack and RCA according to the hp-jack state */
9508 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9509 {
9510         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9511
9512         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9513                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9514         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9515                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9516 }
9517
9518 /* toggle RCA according to the front-jack state */
9519 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9520 {
9521         unsigned int present = snd_hda_jack_detect(codec, 0x14);
9522
9523         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9524                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9525 }
9526
9527 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9528                                              unsigned int res)
9529 {
9530         if ((res >> 26) == ALC880_HP_EVENT)
9531                 alc888_lenovo_ms7195_front_automute(codec);
9532         if ((res >> 26) == ALC880_FRONT_EVENT)
9533                 alc888_lenovo_ms7195_rca_automute(codec);
9534 }
9535
9536 /* toggle speaker-output according to the hp-jack state */
9537 static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9538 {
9539         struct alc_spec *spec = codec->spec;
9540
9541         spec->autocfg.hp_pins[0] = 0x14;
9542         spec->autocfg.speaker_pins[0] = 0x15;
9543 }
9544
9545 /* toggle speaker-output according to the hp-jack state */
9546 #define alc883_targa_init_hook          alc882_targa_init_hook
9547 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9548
9549 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9550 {
9551         struct alc_spec *spec = codec->spec;
9552
9553         spec->autocfg.hp_pins[0] = 0x15;
9554         spec->autocfg.speaker_pins[0] = 0x14;
9555 }
9556
9557 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9558 {
9559         alc_automute_amp(codec);
9560         alc88x_simple_mic_automute(codec);
9561 }
9562
9563 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9564                                            unsigned int res)
9565 {
9566         switch (res >> 26) {
9567         case ALC880_MIC_EVENT:
9568                 alc88x_simple_mic_automute(codec);
9569                 break;
9570         default:
9571                 alc_automute_amp_unsol_event(codec, res);
9572                 break;
9573         }
9574 }
9575
9576 /* toggle speaker-output according to the hp-jack state */
9577 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9578 {
9579         struct alc_spec *spec = codec->spec;
9580
9581         spec->autocfg.hp_pins[0] = 0x14;
9582         spec->autocfg.speaker_pins[0] = 0x15;
9583 }
9584
9585 static void alc883_haier_w66_setup(struct hda_codec *codec)
9586 {
9587         struct alc_spec *spec = codec->spec;
9588
9589         spec->autocfg.hp_pins[0] = 0x1b;
9590         spec->autocfg.speaker_pins[0] = 0x14;
9591 }
9592
9593 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9594 {
9595         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9596
9597         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9598                                  HDA_AMP_MUTE, bits);
9599 }
9600
9601 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9602 {
9603         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9604
9605         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9606                                  HDA_AMP_MUTE, bits);
9607         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9608                                  HDA_AMP_MUTE, bits);
9609 }
9610
9611 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9612                                            unsigned int res)
9613 {
9614         if ((res >> 26) == ALC880_HP_EVENT)
9615                 alc883_lenovo_101e_all_automute(codec);
9616         if ((res >> 26) == ALC880_FRONT_EVENT)
9617                 alc883_lenovo_101e_ispeaker_automute(codec);
9618 }
9619
9620 /* toggle speaker-output according to the hp-jack state */
9621 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9622 {
9623         struct alc_spec *spec = codec->spec;
9624
9625         spec->autocfg.hp_pins[0] = 0x14;
9626         spec->autocfg.speaker_pins[0] = 0x15;
9627         spec->autocfg.speaker_pins[1] = 0x16;
9628 }
9629
9630 static struct hda_verb alc883_acer_eapd_verbs[] = {
9631         /* HP Pin: output 0 (0x0c) */
9632         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9633         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9634         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9635         /* Front Pin: output 0 (0x0c) */
9636         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9637         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9638         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9639         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9640         /* eanable EAPD on medion laptop */
9641         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9642         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9643         /* enable unsolicited event */
9644         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9645         { }
9646 };
9647
9648 static void alc888_6st_dell_setup(struct hda_codec *codec)
9649 {
9650         struct alc_spec *spec = codec->spec;
9651
9652         spec->autocfg.hp_pins[0] = 0x1b;
9653         spec->autocfg.speaker_pins[0] = 0x14;
9654         spec->autocfg.speaker_pins[1] = 0x15;
9655         spec->autocfg.speaker_pins[2] = 0x16;
9656         spec->autocfg.speaker_pins[3] = 0x17;
9657 }
9658
9659 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9660 {
9661         struct alc_spec *spec = codec->spec;
9662
9663         spec->autocfg.hp_pins[0] = 0x1b;
9664         spec->autocfg.speaker_pins[0] = 0x14;
9665         spec->autocfg.speaker_pins[1] = 0x15;
9666         spec->autocfg.speaker_pins[2] = 0x16;
9667         spec->autocfg.speaker_pins[3] = 0x17;
9668         spec->autocfg.speaker_pins[4] = 0x1a;
9669 }
9670
9671 static void alc883_vaiott_setup(struct hda_codec *codec)
9672 {
9673         struct alc_spec *spec = codec->spec;
9674
9675         spec->autocfg.hp_pins[0] = 0x15;
9676         spec->autocfg.speaker_pins[0] = 0x14;
9677         spec->autocfg.speaker_pins[1] = 0x17;
9678 }
9679
9680 static struct hda_verb alc888_asus_m90v_verbs[] = {
9681         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9682         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9683         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9684         /* enable unsolicited event */
9685         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9686         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9687         { } /* end */
9688 };
9689
9690 static void alc883_mode2_setup(struct hda_codec *codec)
9691 {
9692         struct alc_spec *spec = codec->spec;
9693
9694         spec->autocfg.hp_pins[0] = 0x1b;
9695         spec->autocfg.speaker_pins[0] = 0x14;
9696         spec->autocfg.speaker_pins[1] = 0x15;
9697         spec->autocfg.speaker_pins[2] = 0x16;
9698         spec->ext_mic.pin = 0x18;
9699         spec->int_mic.pin = 0x19;
9700         spec->ext_mic.mux_idx = 0;
9701         spec->int_mic.mux_idx = 1;
9702         spec->auto_mic = 1;
9703 }
9704
9705 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9706         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9707         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9708         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9709         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9710         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9711         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9712         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9713         /* enable unsolicited event */
9714         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9715         { } /* end */
9716 };
9717
9718 static void alc883_eee1601_inithook(struct hda_codec *codec)
9719 {
9720         struct alc_spec *spec = codec->spec;
9721
9722         spec->autocfg.hp_pins[0] = 0x14;
9723         spec->autocfg.speaker_pins[0] = 0x1b;
9724         alc_automute_pin(codec);
9725 }
9726
9727 static struct hda_verb alc889A_mb31_verbs[] = {
9728         /* Init rear pin (used as headphone output) */
9729         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9730         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9731         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9732         /* Init line pin (used as output in 4ch and 6ch mode) */
9733         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9734         /* Init line 2 pin (used as headphone out by default) */
9735         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9736         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9737         { } /* end */
9738 };
9739
9740 /* Mute speakers according to the headphone jack state */
9741 static void alc889A_mb31_automute(struct hda_codec *codec)
9742 {
9743         unsigned int present;
9744
9745         /* Mute only in 2ch or 4ch mode */
9746         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9747             == 0x00) {
9748                 present = snd_hda_jack_detect(codec, 0x15);
9749                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9750                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9751                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9752                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9753         }
9754 }
9755
9756 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9757 {
9758         if ((res >> 26) == ALC880_HP_EVENT)
9759                 alc889A_mb31_automute(codec);
9760 }
9761
9762
9763 #ifdef CONFIG_SND_HDA_POWER_SAVE
9764 #define alc882_loopbacks        alc880_loopbacks
9765 #endif
9766
9767 /* pcm configuration: identical with ALC880 */
9768 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9769 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9770 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9771 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9772
9773 static hda_nid_t alc883_slave_dig_outs[] = {
9774         ALC1200_DIGOUT_NID, 0,
9775 };
9776
9777 static hda_nid_t alc1200_slave_dig_outs[] = {
9778         ALC883_DIGOUT_NID, 0,
9779 };
9780
9781 /*
9782  * configuration and preset
9783  */
9784 static const char * const alc882_models[ALC882_MODEL_LAST] = {
9785         [ALC882_3ST_DIG]        = "3stack-dig",
9786         [ALC882_6ST_DIG]        = "6stack-dig",
9787         [ALC882_ARIMA]          = "arima",
9788         [ALC882_W2JC]           = "w2jc",
9789         [ALC882_TARGA]          = "targa",
9790         [ALC882_ASUS_A7J]       = "asus-a7j",
9791         [ALC882_ASUS_A7M]       = "asus-a7m",
9792         [ALC885_MACPRO]         = "macpro",
9793         [ALC885_MB5]            = "mb5",
9794         [ALC885_MACMINI3]       = "macmini3",
9795         [ALC885_MBA21]          = "mba21",
9796         [ALC885_MBP3]           = "mbp3",
9797         [ALC885_IMAC24]         = "imac24",
9798         [ALC885_IMAC91]         = "imac91",
9799         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9800         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9801         [ALC883_3ST_6ch]        = "3stack-6ch",
9802         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9803         [ALC883_TARGA_DIG]      = "targa-dig",
9804         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9805         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9806         [ALC883_ACER]           = "acer",
9807         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9808         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9809         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9810         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9811         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9812         [ALC883_MEDION]         = "medion",
9813         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9814         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9815         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9816         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9817         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9818         [ALC888_LENOVO_SKY] = "lenovo-sky",
9819         [ALC883_HAIER_W66]      = "haier-w66",
9820         [ALC888_3ST_HP]         = "3stack-hp",
9821         [ALC888_6ST_DELL]       = "6stack-dell",
9822         [ALC883_MITAC]          = "mitac",
9823         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9824         [ALC883_CLEVO_M720]     = "clevo-m720",
9825         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9826         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9827         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9828         [ALC889A_INTEL]         = "intel-alc889a",
9829         [ALC889_INTEL]          = "intel-x58",
9830         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9831         [ALC889A_MB31]          = "mb31",
9832         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9833         [ALC882_AUTO]           = "auto",
9834 };
9835
9836 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9837         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9838
9839         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9840         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9841         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9842         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9843         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9844         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9845         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9846                 ALC888_ACER_ASPIRE_4930G),
9847         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9848                 ALC888_ACER_ASPIRE_4930G),
9849         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9850                 ALC888_ACER_ASPIRE_8930G),
9851         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9852                 ALC888_ACER_ASPIRE_8930G),
9853         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9854         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9855         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9856                 ALC888_ACER_ASPIRE_6530G),
9857         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9858                 ALC888_ACER_ASPIRE_6530G),
9859         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9860                 ALC888_ACER_ASPIRE_7730G),
9861         /* default Acer -- disabled as it causes more problems.
9862          *    model=auto should work fine now
9863          */
9864         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9865
9866         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9867
9868         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9869         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9870         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9871         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9872         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9873         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9874
9875         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9876         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9877         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9878         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9879         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9880         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9881         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9882         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9883         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9884         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9885         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9886
9887         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9888         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9889         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9890         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9891         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9892         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9893         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9894         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9895         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9896
9897         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9898         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9899         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9900         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9901         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9902         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9903         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9904         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9905         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9906         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9907         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9908         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9909         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9910         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9911         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9912         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9913         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9914         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9915         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9916         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9917         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9918         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9919         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9920         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9921         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9922         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9923         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9924         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9925         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9926         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9927         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9928
9929         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9930         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9931         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9932         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9933         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9934         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9935         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9936         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9937         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9938         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9939                       ALC883_FUJITSU_PI2515),
9940         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9941                 ALC888_FUJITSU_XA3530),
9942         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9943         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9944         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9945         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9946         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9947         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9948         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9949         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9950
9951         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9952         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9953         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9954         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9955         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9956         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9957         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9958
9959         {}
9960 };
9961
9962 /* codec SSID table for Intel Mac */
9963 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9964         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9965         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9966         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9967         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9968         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9969         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9970         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9971         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9972         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9973         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9974         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9975         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9976         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9977         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9978         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9979         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9980         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9981         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9982          * so apparently no perfect solution yet
9983          */
9984         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9985         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9986         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9987         {} /* terminator */
9988 };
9989
9990 static struct alc_config_preset alc882_presets[] = {
9991         [ALC882_3ST_DIG] = {
9992                 .mixers = { alc882_base_mixer },
9993                 .init_verbs = { alc882_base_init_verbs,
9994                                 alc882_adc1_init_verbs },
9995                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9996                 .dac_nids = alc882_dac_nids,
9997                 .dig_out_nid = ALC882_DIGOUT_NID,
9998                 .dig_in_nid = ALC882_DIGIN_NID,
9999                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10000                 .channel_mode = alc882_ch_modes,
10001                 .need_dac_fix = 1,
10002                 .input_mux = &alc882_capture_source,
10003         },
10004         [ALC882_6ST_DIG] = {
10005                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10006                 .init_verbs = { alc882_base_init_verbs,
10007                                 alc882_adc1_init_verbs },
10008                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10009                 .dac_nids = alc882_dac_nids,
10010                 .dig_out_nid = ALC882_DIGOUT_NID,
10011                 .dig_in_nid = ALC882_DIGIN_NID,
10012                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10013                 .channel_mode = alc882_sixstack_modes,
10014                 .input_mux = &alc882_capture_source,
10015         },
10016         [ALC882_ARIMA] = {
10017                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10018                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10019                                 alc882_eapd_verbs },
10020                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10021                 .dac_nids = alc882_dac_nids,
10022                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10023                 .channel_mode = alc882_sixstack_modes,
10024                 .input_mux = &alc882_capture_source,
10025         },
10026         [ALC882_W2JC] = {
10027                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
10028                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10029                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
10030                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10031                 .dac_nids = alc882_dac_nids,
10032                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10033                 .channel_mode = alc880_threestack_modes,
10034                 .need_dac_fix = 1,
10035                 .input_mux = &alc882_capture_source,
10036                 .dig_out_nid = ALC882_DIGOUT_NID,
10037         },
10038            [ALC885_MBA21] = {
10039                         .mixers = { alc885_mba21_mixer },
10040                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
10041                         .num_dacs = 2,
10042                         .dac_nids = alc882_dac_nids,
10043                         .channel_mode = alc885_mba21_ch_modes,
10044                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10045                         .input_mux = &alc882_capture_source,
10046                         .unsol_event = alc_automute_amp_unsol_event,
10047                         .setup = alc885_mba21_setup,
10048                         .init_hook = alc_automute_amp,
10049        },
10050         [ALC885_MBP3] = {
10051                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
10052                 .init_verbs = { alc885_mbp3_init_verbs,
10053                                 alc880_gpio1_init_verbs },
10054                 .num_dacs = 2,
10055                 .dac_nids = alc882_dac_nids,
10056                 .hp_nid = 0x04,
10057                 .channel_mode = alc885_mbp_4ch_modes,
10058                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10059                 .input_mux = &alc882_capture_source,
10060                 .dig_out_nid = ALC882_DIGOUT_NID,
10061                 .dig_in_nid = ALC882_DIGIN_NID,
10062                 .unsol_event = alc_automute_amp_unsol_event,
10063                 .setup = alc885_mbp3_setup,
10064                 .init_hook = alc_automute_amp,
10065         },
10066         [ALC885_MB5] = {
10067                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10068                 .init_verbs = { alc885_mb5_init_verbs,
10069                                 alc880_gpio1_init_verbs },
10070                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10071                 .dac_nids = alc882_dac_nids,
10072                 .channel_mode = alc885_mb5_6ch_modes,
10073                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10074                 .input_mux = &mb5_capture_source,
10075                 .dig_out_nid = ALC882_DIGOUT_NID,
10076                 .dig_in_nid = ALC882_DIGIN_NID,
10077                 .unsol_event = alc_automute_amp_unsol_event,
10078                 .setup = alc885_mb5_setup,
10079                 .init_hook = alc_automute_amp,
10080         },
10081         [ALC885_MACMINI3] = {
10082                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10083                 .init_verbs = { alc885_macmini3_init_verbs,
10084                                 alc880_gpio1_init_verbs },
10085                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10086                 .dac_nids = alc882_dac_nids,
10087                 .channel_mode = alc885_macmini3_6ch_modes,
10088                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10089                 .input_mux = &macmini3_capture_source,
10090                 .dig_out_nid = ALC882_DIGOUT_NID,
10091                 .dig_in_nid = ALC882_DIGIN_NID,
10092                 .unsol_event = alc_automute_amp_unsol_event,
10093                 .setup = alc885_macmini3_setup,
10094                 .init_hook = alc_automute_amp,
10095         },
10096         [ALC885_MACPRO] = {
10097                 .mixers = { alc882_macpro_mixer },
10098                 .init_verbs = { alc882_macpro_init_verbs },
10099                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10100                 .dac_nids = alc882_dac_nids,
10101                 .dig_out_nid = ALC882_DIGOUT_NID,
10102                 .dig_in_nid = ALC882_DIGIN_NID,
10103                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10104                 .channel_mode = alc882_ch_modes,
10105                 .input_mux = &alc882_capture_source,
10106                 .init_hook = alc885_macpro_init_hook,
10107         },
10108         [ALC885_IMAC24] = {
10109                 .mixers = { alc885_imac24_mixer },
10110                 .init_verbs = { alc885_imac24_init_verbs },
10111                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10112                 .dac_nids = alc882_dac_nids,
10113                 .dig_out_nid = ALC882_DIGOUT_NID,
10114                 .dig_in_nid = ALC882_DIGIN_NID,
10115                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10116                 .channel_mode = alc882_ch_modes,
10117                 .input_mux = &alc882_capture_source,
10118                 .unsol_event = alc_automute_amp_unsol_event,
10119                 .setup = alc885_imac24_setup,
10120                 .init_hook = alc885_imac24_init_hook,
10121         },
10122         [ALC885_IMAC91] = {
10123                 .mixers = {alc885_imac91_mixer},
10124                 .init_verbs = { alc885_imac91_init_verbs,
10125                                 alc880_gpio1_init_verbs },
10126                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10127                 .dac_nids = alc882_dac_nids,
10128                 .channel_mode = alc885_mba21_ch_modes,
10129                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10130                 .input_mux = &alc889A_imac91_capture_source,
10131                 .dig_out_nid = ALC882_DIGOUT_NID,
10132                 .dig_in_nid = ALC882_DIGIN_NID,
10133                 .unsol_event = alc_automute_amp_unsol_event,
10134                 .setup = alc885_imac91_setup,
10135                 .init_hook = alc_automute_amp,
10136         },
10137         [ALC882_TARGA] = {
10138                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10139                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10140                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
10141                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10142                 .dac_nids = alc882_dac_nids,
10143                 .dig_out_nid = ALC882_DIGOUT_NID,
10144                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10145                 .adc_nids = alc882_adc_nids,
10146                 .capsrc_nids = alc882_capsrc_nids,
10147                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10148                 .channel_mode = alc882_3ST_6ch_modes,
10149                 .need_dac_fix = 1,
10150                 .input_mux = &alc882_capture_source,
10151                 .unsol_event = alc882_targa_unsol_event,
10152                 .setup = alc882_targa_setup,
10153                 .init_hook = alc882_targa_automute,
10154         },
10155         [ALC882_ASUS_A7J] = {
10156                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10157                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10158                                 alc882_asus_a7j_verbs},
10159                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10160                 .dac_nids = alc882_dac_nids,
10161                 .dig_out_nid = ALC882_DIGOUT_NID,
10162                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10163                 .adc_nids = alc882_adc_nids,
10164                 .capsrc_nids = alc882_capsrc_nids,
10165                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10166                 .channel_mode = alc882_3ST_6ch_modes,
10167                 .need_dac_fix = 1,
10168                 .input_mux = &alc882_capture_source,
10169         },
10170         [ALC882_ASUS_A7M] = {
10171                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10172                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10173                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10174                                 alc882_asus_a7m_verbs },
10175                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10176                 .dac_nids = alc882_dac_nids,
10177                 .dig_out_nid = ALC882_DIGOUT_NID,
10178                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10179                 .channel_mode = alc880_threestack_modes,
10180                 .need_dac_fix = 1,
10181                 .input_mux = &alc882_capture_source,
10182         },
10183         [ALC883_3ST_2ch_DIG] = {
10184                 .mixers = { alc883_3ST_2ch_mixer },
10185                 .init_verbs = { alc883_init_verbs },
10186                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10187                 .dac_nids = alc883_dac_nids,
10188                 .dig_out_nid = ALC883_DIGOUT_NID,
10189                 .dig_in_nid = ALC883_DIGIN_NID,
10190                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10191                 .channel_mode = alc883_3ST_2ch_modes,
10192                 .input_mux = &alc883_capture_source,
10193         },
10194         [ALC883_3ST_6ch_DIG] = {
10195                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10196                 .init_verbs = { alc883_init_verbs },
10197                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10198                 .dac_nids = alc883_dac_nids,
10199                 .dig_out_nid = ALC883_DIGOUT_NID,
10200                 .dig_in_nid = ALC883_DIGIN_NID,
10201                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10202                 .channel_mode = alc883_3ST_6ch_modes,
10203                 .need_dac_fix = 1,
10204                 .input_mux = &alc883_capture_source,
10205         },
10206         [ALC883_3ST_6ch] = {
10207                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10208                 .init_verbs = { alc883_init_verbs },
10209                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10210                 .dac_nids = alc883_dac_nids,
10211                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10212                 .channel_mode = alc883_3ST_6ch_modes,
10213                 .need_dac_fix = 1,
10214                 .input_mux = &alc883_capture_source,
10215         },
10216         [ALC883_3ST_6ch_INTEL] = {
10217                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10218                 .init_verbs = { alc883_init_verbs },
10219                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10220                 .dac_nids = alc883_dac_nids,
10221                 .dig_out_nid = ALC883_DIGOUT_NID,
10222                 .dig_in_nid = ALC883_DIGIN_NID,
10223                 .slave_dig_outs = alc883_slave_dig_outs,
10224                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10225                 .channel_mode = alc883_3ST_6ch_intel_modes,
10226                 .need_dac_fix = 1,
10227                 .input_mux = &alc883_3stack_6ch_intel,
10228         },
10229         [ALC889A_INTEL] = {
10230                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10231                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10232                                 alc_hp15_unsol_verbs },
10233                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10234                 .dac_nids = alc883_dac_nids,
10235                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10236                 .adc_nids = alc889_adc_nids,
10237                 .dig_out_nid = ALC883_DIGOUT_NID,
10238                 .dig_in_nid = ALC883_DIGIN_NID,
10239                 .slave_dig_outs = alc883_slave_dig_outs,
10240                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10241                 .channel_mode = alc889_8ch_intel_modes,
10242                 .capsrc_nids = alc889_capsrc_nids,
10243                 .input_mux = &alc889_capture_source,
10244                 .setup = alc889_automute_setup,
10245                 .init_hook = alc_automute_amp,
10246                 .unsol_event = alc_automute_amp_unsol_event,
10247                 .need_dac_fix = 1,
10248         },
10249         [ALC889_INTEL] = {
10250                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10251                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10252                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10253                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10254                 .dac_nids = alc883_dac_nids,
10255                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10256                 .adc_nids = alc889_adc_nids,
10257                 .dig_out_nid = ALC883_DIGOUT_NID,
10258                 .dig_in_nid = ALC883_DIGIN_NID,
10259                 .slave_dig_outs = alc883_slave_dig_outs,
10260                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10261                 .channel_mode = alc889_8ch_intel_modes,
10262                 .capsrc_nids = alc889_capsrc_nids,
10263                 .input_mux = &alc889_capture_source,
10264                 .setup = alc889_automute_setup,
10265                 .init_hook = alc889_intel_init_hook,
10266                 .unsol_event = alc_automute_amp_unsol_event,
10267                 .need_dac_fix = 1,
10268         },
10269         [ALC883_6ST_DIG] = {
10270                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10271                 .init_verbs = { alc883_init_verbs },
10272                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10273                 .dac_nids = alc883_dac_nids,
10274                 .dig_out_nid = ALC883_DIGOUT_NID,
10275                 .dig_in_nid = ALC883_DIGIN_NID,
10276                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10277                 .channel_mode = alc883_sixstack_modes,
10278                 .input_mux = &alc883_capture_source,
10279         },
10280         [ALC883_TARGA_DIG] = {
10281                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10282                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10283                                 alc883_targa_verbs},
10284                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10285                 .dac_nids = alc883_dac_nids,
10286                 .dig_out_nid = ALC883_DIGOUT_NID,
10287                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10288                 .channel_mode = alc883_3ST_6ch_modes,
10289                 .need_dac_fix = 1,
10290                 .input_mux = &alc883_capture_source,
10291                 .unsol_event = alc883_targa_unsol_event,
10292                 .setup = alc882_targa_setup,
10293                 .init_hook = alc882_targa_automute,
10294         },
10295         [ALC883_TARGA_2ch_DIG] = {
10296                 .mixers = { alc883_targa_2ch_mixer},
10297                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10298                                 alc883_targa_verbs},
10299                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10300                 .dac_nids = alc883_dac_nids,
10301                 .adc_nids = alc883_adc_nids_alt,
10302                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10303                 .capsrc_nids = alc883_capsrc_nids,
10304                 .dig_out_nid = ALC883_DIGOUT_NID,
10305                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10306                 .channel_mode = alc883_3ST_2ch_modes,
10307                 .input_mux = &alc883_capture_source,
10308                 .unsol_event = alc883_targa_unsol_event,
10309                 .setup = alc882_targa_setup,
10310                 .init_hook = alc882_targa_automute,
10311         },
10312         [ALC883_TARGA_8ch_DIG] = {
10313                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10314                             alc883_chmode_mixer },
10315                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10316                                 alc883_targa_verbs },
10317                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10318                 .dac_nids = alc883_dac_nids,
10319                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10320                 .adc_nids = alc883_adc_nids_rev,
10321                 .capsrc_nids = alc883_capsrc_nids_rev,
10322                 .dig_out_nid = ALC883_DIGOUT_NID,
10323                 .dig_in_nid = ALC883_DIGIN_NID,
10324                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10325                 .channel_mode = alc883_4ST_8ch_modes,
10326                 .need_dac_fix = 1,
10327                 .input_mux = &alc883_capture_source,
10328                 .unsol_event = alc883_targa_unsol_event,
10329                 .setup = alc882_targa_setup,
10330                 .init_hook = alc882_targa_automute,
10331         },
10332         [ALC883_ACER] = {
10333                 .mixers = { alc883_base_mixer },
10334                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10335                  * and the headphone jack.  Turn this on and rely on the
10336                  * standard mute methods whenever the user wants to turn
10337                  * these outputs off.
10338                  */
10339                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10340                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10341                 .dac_nids = alc883_dac_nids,
10342                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10343                 .channel_mode = alc883_3ST_2ch_modes,
10344                 .input_mux = &alc883_capture_source,
10345         },
10346         [ALC883_ACER_ASPIRE] = {
10347                 .mixers = { alc883_acer_aspire_mixer },
10348                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10349                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10350                 .dac_nids = alc883_dac_nids,
10351                 .dig_out_nid = ALC883_DIGOUT_NID,
10352                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10353                 .channel_mode = alc883_3ST_2ch_modes,
10354                 .input_mux = &alc883_capture_source,
10355                 .unsol_event = alc_automute_amp_unsol_event,
10356                 .setup = alc883_acer_aspire_setup,
10357                 .init_hook = alc_automute_amp,
10358         },
10359         [ALC888_ACER_ASPIRE_4930G] = {
10360                 .mixers = { alc888_base_mixer,
10361                                 alc883_chmode_mixer },
10362                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10363                                 alc888_acer_aspire_4930g_verbs },
10364                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10365                 .dac_nids = alc883_dac_nids,
10366                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10367                 .adc_nids = alc883_adc_nids_rev,
10368                 .capsrc_nids = alc883_capsrc_nids_rev,
10369                 .dig_out_nid = ALC883_DIGOUT_NID,
10370                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10371                 .channel_mode = alc883_3ST_6ch_modes,
10372                 .need_dac_fix = 1,
10373                 .const_channel_count = 6,
10374                 .num_mux_defs =
10375                         ARRAY_SIZE(alc888_2_capture_sources),
10376                 .input_mux = alc888_2_capture_sources,
10377                 .unsol_event = alc_automute_amp_unsol_event,
10378                 .setup = alc888_acer_aspire_4930g_setup,
10379                 .init_hook = alc_automute_amp,
10380         },
10381         [ALC888_ACER_ASPIRE_6530G] = {
10382                 .mixers = { alc888_acer_aspire_6530_mixer },
10383                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10384                                 alc888_acer_aspire_6530g_verbs },
10385                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10386                 .dac_nids = alc883_dac_nids,
10387                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10388                 .adc_nids = alc883_adc_nids_rev,
10389                 .capsrc_nids = alc883_capsrc_nids_rev,
10390                 .dig_out_nid = ALC883_DIGOUT_NID,
10391                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10392                 .channel_mode = alc883_3ST_2ch_modes,
10393                 .num_mux_defs =
10394                         ARRAY_SIZE(alc888_2_capture_sources),
10395                 .input_mux = alc888_acer_aspire_6530_sources,
10396                 .unsol_event = alc_automute_amp_unsol_event,
10397                 .setup = alc888_acer_aspire_6530g_setup,
10398                 .init_hook = alc_automute_amp,
10399         },
10400         [ALC888_ACER_ASPIRE_8930G] = {
10401                 .mixers = { alc889_acer_aspire_8930g_mixer,
10402                                 alc883_chmode_mixer },
10403                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10404                                 alc889_acer_aspire_8930g_verbs,
10405                                 alc889_eapd_verbs},
10406                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10407                 .dac_nids = alc883_dac_nids,
10408                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10409                 .adc_nids = alc889_adc_nids,
10410                 .capsrc_nids = alc889_capsrc_nids,
10411                 .dig_out_nid = ALC883_DIGOUT_NID,
10412                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10413                 .channel_mode = alc883_3ST_6ch_modes,
10414                 .need_dac_fix = 1,
10415                 .const_channel_count = 6,
10416                 .num_mux_defs =
10417                         ARRAY_SIZE(alc889_capture_sources),
10418                 .input_mux = alc889_capture_sources,
10419                 .unsol_event = alc_automute_amp_unsol_event,
10420                 .setup = alc889_acer_aspire_8930g_setup,
10421                 .init_hook = alc_automute_amp,
10422 #ifdef CONFIG_SND_HDA_POWER_SAVE
10423                 .power_hook = alc_power_eapd,
10424 #endif
10425         },
10426         [ALC888_ACER_ASPIRE_7730G] = {
10427                 .mixers = { alc883_3ST_6ch_mixer,
10428                                 alc883_chmode_mixer },
10429                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10430                                 alc888_acer_aspire_7730G_verbs },
10431                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10432                 .dac_nids = alc883_dac_nids,
10433                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10434                 .adc_nids = alc883_adc_nids_rev,
10435                 .capsrc_nids = alc883_capsrc_nids_rev,
10436                 .dig_out_nid = ALC883_DIGOUT_NID,
10437                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10438                 .channel_mode = alc883_3ST_6ch_modes,
10439                 .need_dac_fix = 1,
10440                 .const_channel_count = 6,
10441                 .input_mux = &alc883_capture_source,
10442                 .unsol_event = alc_automute_amp_unsol_event,
10443                 .setup = alc888_acer_aspire_7730g_setup,
10444                 .init_hook = alc_automute_amp,
10445         },
10446         [ALC883_MEDION] = {
10447                 .mixers = { alc883_fivestack_mixer,
10448                             alc883_chmode_mixer },
10449                 .init_verbs = { alc883_init_verbs,
10450                                 alc883_medion_eapd_verbs },
10451                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10452                 .dac_nids = alc883_dac_nids,
10453                 .adc_nids = alc883_adc_nids_alt,
10454                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10455                 .capsrc_nids = alc883_capsrc_nids,
10456                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10457                 .channel_mode = alc883_sixstack_modes,
10458                 .input_mux = &alc883_capture_source,
10459         },
10460         [ALC883_MEDION_WIM2160] = {
10461                 .mixers = { alc883_medion_wim2160_mixer },
10462                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10463                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10464                 .dac_nids = alc883_dac_nids,
10465                 .dig_out_nid = ALC883_DIGOUT_NID,
10466                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10467                 .adc_nids = alc883_adc_nids,
10468                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10469                 .channel_mode = alc883_3ST_2ch_modes,
10470                 .input_mux = &alc883_capture_source,
10471                 .unsol_event = alc_automute_amp_unsol_event,
10472                 .setup = alc883_medion_wim2160_setup,
10473                 .init_hook = alc_automute_amp,
10474         },
10475         [ALC883_LAPTOP_EAPD] = {
10476                 .mixers = { alc883_base_mixer },
10477                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10478                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10479                 .dac_nids = alc883_dac_nids,
10480                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10481                 .channel_mode = alc883_3ST_2ch_modes,
10482                 .input_mux = &alc883_capture_source,
10483         },
10484         [ALC883_CLEVO_M540R] = {
10485                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10486                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10487                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10488                 .dac_nids = alc883_dac_nids,
10489                 .dig_out_nid = ALC883_DIGOUT_NID,
10490                 .dig_in_nid = ALC883_DIGIN_NID,
10491                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10492                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10493                 .need_dac_fix = 1,
10494                 .input_mux = &alc883_capture_source,
10495                 /* This machine has the hardware HP auto-muting, thus
10496                  * we need no software mute via unsol event
10497                  */
10498         },
10499         [ALC883_CLEVO_M720] = {
10500                 .mixers = { alc883_clevo_m720_mixer },
10501                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10502                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10503                 .dac_nids = alc883_dac_nids,
10504                 .dig_out_nid = ALC883_DIGOUT_NID,
10505                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10506                 .channel_mode = alc883_3ST_2ch_modes,
10507                 .input_mux = &alc883_capture_source,
10508                 .unsol_event = alc883_clevo_m720_unsol_event,
10509                 .setup = alc883_clevo_m720_setup,
10510                 .init_hook = alc883_clevo_m720_init_hook,
10511         },
10512         [ALC883_LENOVO_101E_2ch] = {
10513                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10514                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10515                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10516                 .dac_nids = alc883_dac_nids,
10517                 .adc_nids = alc883_adc_nids_alt,
10518                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10519                 .capsrc_nids = alc883_capsrc_nids,
10520                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10521                 .channel_mode = alc883_3ST_2ch_modes,
10522                 .input_mux = &alc883_lenovo_101e_capture_source,
10523                 .unsol_event = alc883_lenovo_101e_unsol_event,
10524                 .init_hook = alc883_lenovo_101e_all_automute,
10525         },
10526         [ALC883_LENOVO_NB0763] = {
10527                 .mixers = { alc883_lenovo_nb0763_mixer },
10528                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10529                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10530                 .dac_nids = alc883_dac_nids,
10531                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10532                 .channel_mode = alc883_3ST_2ch_modes,
10533                 .need_dac_fix = 1,
10534                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10535                 .unsol_event = alc_automute_amp_unsol_event,
10536                 .setup = alc883_lenovo_nb0763_setup,
10537                 .init_hook = alc_automute_amp,
10538         },
10539         [ALC888_LENOVO_MS7195_DIG] = {
10540                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10541                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10542                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10543                 .dac_nids = alc883_dac_nids,
10544                 .dig_out_nid = ALC883_DIGOUT_NID,
10545                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10546                 .channel_mode = alc883_3ST_6ch_modes,
10547                 .need_dac_fix = 1,
10548                 .input_mux = &alc883_capture_source,
10549                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
10550                 .init_hook = alc888_lenovo_ms7195_front_automute,
10551         },
10552         [ALC883_HAIER_W66] = {
10553                 .mixers = { alc883_targa_2ch_mixer},
10554                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10555                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10556                 .dac_nids = alc883_dac_nids,
10557                 .dig_out_nid = ALC883_DIGOUT_NID,
10558                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10559                 .channel_mode = alc883_3ST_2ch_modes,
10560                 .input_mux = &alc883_capture_source,
10561                 .unsol_event = alc_automute_amp_unsol_event,
10562                 .setup = alc883_haier_w66_setup,
10563                 .init_hook = alc_automute_amp,
10564         },
10565         [ALC888_3ST_HP] = {
10566                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10567                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10568                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10569                 .dac_nids = alc883_dac_nids,
10570                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10571                 .channel_mode = alc888_3st_hp_modes,
10572                 .need_dac_fix = 1,
10573                 .input_mux = &alc883_capture_source,
10574                 .unsol_event = alc_automute_amp_unsol_event,
10575                 .setup = alc888_3st_hp_setup,
10576                 .init_hook = alc_automute_amp,
10577         },
10578         [ALC888_6ST_DELL] = {
10579                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10580                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10581                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10582                 .dac_nids = alc883_dac_nids,
10583                 .dig_out_nid = ALC883_DIGOUT_NID,
10584                 .dig_in_nid = ALC883_DIGIN_NID,
10585                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10586                 .channel_mode = alc883_sixstack_modes,
10587                 .input_mux = &alc883_capture_source,
10588                 .unsol_event = alc_automute_amp_unsol_event,
10589                 .setup = alc888_6st_dell_setup,
10590                 .init_hook = alc_automute_amp,
10591         },
10592         [ALC883_MITAC] = {
10593                 .mixers = { alc883_mitac_mixer },
10594                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10595                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10596                 .dac_nids = alc883_dac_nids,
10597                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10598                 .channel_mode = alc883_3ST_2ch_modes,
10599                 .input_mux = &alc883_capture_source,
10600                 .unsol_event = alc_automute_amp_unsol_event,
10601                 .setup = alc883_mitac_setup,
10602                 .init_hook = alc_automute_amp,
10603         },
10604         [ALC883_FUJITSU_PI2515] = {
10605                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10606                 .init_verbs = { alc883_init_verbs,
10607                                 alc883_2ch_fujitsu_pi2515_verbs},
10608                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10609                 .dac_nids = alc883_dac_nids,
10610                 .dig_out_nid = ALC883_DIGOUT_NID,
10611                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10612                 .channel_mode = alc883_3ST_2ch_modes,
10613                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10614                 .unsol_event = alc_automute_amp_unsol_event,
10615                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10616                 .init_hook = alc_automute_amp,
10617         },
10618         [ALC888_FUJITSU_XA3530] = {
10619                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10620                 .init_verbs = { alc883_init_verbs,
10621                         alc888_fujitsu_xa3530_verbs },
10622                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10623                 .dac_nids = alc883_dac_nids,
10624                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10625                 .adc_nids = alc883_adc_nids_rev,
10626                 .capsrc_nids = alc883_capsrc_nids_rev,
10627                 .dig_out_nid = ALC883_DIGOUT_NID,
10628                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10629                 .channel_mode = alc888_4ST_8ch_intel_modes,
10630                 .num_mux_defs =
10631                         ARRAY_SIZE(alc888_2_capture_sources),
10632                 .input_mux = alc888_2_capture_sources,
10633                 .unsol_event = alc_automute_amp_unsol_event,
10634                 .setup = alc888_fujitsu_xa3530_setup,
10635                 .init_hook = alc_automute_amp,
10636         },
10637         [ALC888_LENOVO_SKY] = {
10638                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10639                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10640                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10641                 .dac_nids = alc883_dac_nids,
10642                 .dig_out_nid = ALC883_DIGOUT_NID,
10643                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10644                 .channel_mode = alc883_sixstack_modes,
10645                 .need_dac_fix = 1,
10646                 .input_mux = &alc883_lenovo_sky_capture_source,
10647                 .unsol_event = alc_automute_amp_unsol_event,
10648                 .setup = alc888_lenovo_sky_setup,
10649                 .init_hook = alc_automute_amp,
10650         },
10651         [ALC888_ASUS_M90V] = {
10652                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10653                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10654                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10655                 .dac_nids = alc883_dac_nids,
10656                 .dig_out_nid = ALC883_DIGOUT_NID,
10657                 .dig_in_nid = ALC883_DIGIN_NID,
10658                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10659                 .channel_mode = alc883_3ST_6ch_modes,
10660                 .need_dac_fix = 1,
10661                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10662                 .unsol_event = alc_sku_unsol_event,
10663                 .setup = alc883_mode2_setup,
10664                 .init_hook = alc_inithook,
10665         },
10666         [ALC888_ASUS_EEE1601] = {
10667                 .mixers = { alc883_asus_eee1601_mixer },
10668                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10669                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10670                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10671                 .dac_nids = alc883_dac_nids,
10672                 .dig_out_nid = ALC883_DIGOUT_NID,
10673                 .dig_in_nid = ALC883_DIGIN_NID,
10674                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10675                 .channel_mode = alc883_3ST_2ch_modes,
10676                 .need_dac_fix = 1,
10677                 .input_mux = &alc883_asus_eee1601_capture_source,
10678                 .unsol_event = alc_sku_unsol_event,
10679                 .init_hook = alc883_eee1601_inithook,
10680         },
10681         [ALC1200_ASUS_P5Q] = {
10682                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10683                 .init_verbs = { alc883_init_verbs },
10684                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10685                 .dac_nids = alc883_dac_nids,
10686                 .dig_out_nid = ALC1200_DIGOUT_NID,
10687                 .dig_in_nid = ALC883_DIGIN_NID,
10688                 .slave_dig_outs = alc1200_slave_dig_outs,
10689                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10690                 .channel_mode = alc883_sixstack_modes,
10691                 .input_mux = &alc883_capture_source,
10692         },
10693         [ALC889A_MB31] = {
10694                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10695                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10696                         alc880_gpio1_init_verbs },
10697                 .adc_nids = alc883_adc_nids,
10698                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10699                 .capsrc_nids = alc883_capsrc_nids,
10700                 .dac_nids = alc883_dac_nids,
10701                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10702                 .channel_mode = alc889A_mb31_6ch_modes,
10703                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10704                 .input_mux = &alc889A_mb31_capture_source,
10705                 .dig_out_nid = ALC883_DIGOUT_NID,
10706                 .unsol_event = alc889A_mb31_unsol_event,
10707                 .init_hook = alc889A_mb31_automute,
10708         },
10709         [ALC883_SONY_VAIO_TT] = {
10710                 .mixers = { alc883_vaiott_mixer },
10711                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10712                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10713                 .dac_nids = alc883_dac_nids,
10714                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10715                 .channel_mode = alc883_3ST_2ch_modes,
10716                 .input_mux = &alc883_capture_source,
10717                 .unsol_event = alc_automute_amp_unsol_event,
10718                 .setup = alc883_vaiott_setup,
10719                 .init_hook = alc_automute_amp,
10720         },
10721 };
10722
10723
10724 /*
10725  * Pin config fixes
10726  */
10727 enum {
10728         PINFIX_ABIT_AW9D_MAX,
10729         PINFIX_PB_M5210,
10730         PINFIX_ACER_ASPIRE_7736,
10731 };
10732
10733 static const struct alc_fixup alc882_fixups[] = {
10734         [PINFIX_ABIT_AW9D_MAX] = {
10735                 .type = ALC_FIXUP_PINS,
10736                 .v.pins = (const struct alc_pincfg[]) {
10737                         { 0x15, 0x01080104 }, /* side */
10738                         { 0x16, 0x01011012 }, /* rear */
10739                         { 0x17, 0x01016011 }, /* clfe */
10740                         { }
10741                 }
10742         },
10743         [PINFIX_PB_M5210] = {
10744                 .type = ALC_FIXUP_VERBS,
10745                 .v.verbs = (const struct hda_verb[]) {
10746                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10747                         {}
10748                 }
10749         },
10750         [PINFIX_ACER_ASPIRE_7736] = {
10751                 .type = ALC_FIXUP_SKU,
10752                 .v.sku = ALC_FIXUP_SKU_IGNORE,
10753         },
10754 };
10755
10756 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10757         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10758         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10759         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
10760         {}
10761 };
10762
10763 /*
10764  * BIOS auto configuration
10765  */
10766 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10767                                                 const struct auto_pin_cfg *cfg)
10768 {
10769         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10770 }
10771
10772 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10773                                               hda_nid_t nid, int pin_type,
10774                                               hda_nid_t dac)
10775 {
10776         int idx;
10777
10778         /* set as output */
10779         alc_set_pin_output(codec, nid, pin_type);
10780
10781         if (dac == 0x25)
10782                 idx = 4;
10783         else if (dac >= 0x02 && dac <= 0x05)
10784                 idx = dac - 2;
10785         else
10786                 return;
10787         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10788 }
10789
10790 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10791 {
10792         struct alc_spec *spec = codec->spec;
10793         int i;
10794
10795         for (i = 0; i <= HDA_SIDE; i++) {
10796                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10797                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10798                 if (nid)
10799                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10800                                         spec->multiout.dac_nids[i]);
10801         }
10802 }
10803
10804 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10805 {
10806         struct alc_spec *spec = codec->spec;
10807         hda_nid_t pin, dac;
10808         int i;
10809
10810         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10811                 pin = spec->autocfg.hp_pins[i];
10812                 if (!pin)
10813                         break;
10814                 dac = spec->multiout.hp_nid;
10815                 if (!dac)
10816                         dac = spec->multiout.dac_nids[0]; /* to front */
10817                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10818         }
10819         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10820                 pin = spec->autocfg.speaker_pins[i];
10821                 if (!pin)
10822                         break;
10823                 dac = spec->multiout.extra_out_nid[0];
10824                 if (!dac)
10825                         dac = spec->multiout.dac_nids[0]; /* to front */
10826                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10827         }
10828 }
10829
10830 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10831 {
10832         struct alc_spec *spec = codec->spec;
10833         struct auto_pin_cfg *cfg = &spec->autocfg;
10834         int i;
10835
10836         for (i = 0; i < cfg->num_inputs; i++) {
10837                 hda_nid_t nid = cfg->inputs[i].pin;
10838                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10839                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10840                         snd_hda_codec_write(codec, nid, 0,
10841                                             AC_VERB_SET_AMP_GAIN_MUTE,
10842                                             AMP_OUT_MUTE);
10843         }
10844 }
10845
10846 static void alc882_auto_init_input_src(struct hda_codec *codec)
10847 {
10848         struct alc_spec *spec = codec->spec;
10849         int c;
10850
10851         for (c = 0; c < spec->num_adc_nids; c++) {
10852                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10853                 hda_nid_t nid = spec->capsrc_nids[c];
10854                 unsigned int mux_idx;
10855                 const struct hda_input_mux *imux;
10856                 int conns, mute, idx, item;
10857
10858                 conns = snd_hda_get_connections(codec, nid, conn_list,
10859                                                 ARRAY_SIZE(conn_list));
10860                 if (conns < 0)
10861                         continue;
10862                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10863                 imux = &spec->input_mux[mux_idx];
10864                 if (!imux->num_items && mux_idx > 0)
10865                         imux = &spec->input_mux[0];
10866                 for (idx = 0; idx < conns; idx++) {
10867                         /* if the current connection is the selected one,
10868                          * unmute it as default - otherwise mute it
10869                          */
10870                         mute = AMP_IN_MUTE(idx);
10871                         for (item = 0; item < imux->num_items; item++) {
10872                                 if (imux->items[item].index == idx) {
10873                                         if (spec->cur_mux[c] == item)
10874                                                 mute = AMP_IN_UNMUTE(idx);
10875                                         break;
10876                                 }
10877                         }
10878                         /* check if we have a selector or mixer
10879                          * we could check for the widget type instead, but
10880                          * just check for Amp-In presence (in case of mixer
10881                          * without amp-in there is something wrong, this
10882                          * function shouldn't be used or capsrc nid is wrong)
10883                          */
10884                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10885                                 snd_hda_codec_write(codec, nid, 0,
10886                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10887                                                     mute);
10888                         else if (mute != AMP_IN_MUTE(idx))
10889                                 snd_hda_codec_write(codec, nid, 0,
10890                                                     AC_VERB_SET_CONNECT_SEL,
10891                                                     idx);
10892                 }
10893         }
10894 }
10895
10896 /* add mic boosts if needed */
10897 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10898 {
10899         struct alc_spec *spec = codec->spec;
10900         struct auto_pin_cfg *cfg = &spec->autocfg;
10901         int i, err;
10902         int type_idx = 0;
10903         hda_nid_t nid;
10904         const char *prev_label = NULL;
10905
10906         for (i = 0; i < cfg->num_inputs; i++) {
10907                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
10908                         break;
10909                 nid = cfg->inputs[i].pin;
10910                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10911                         const char *label;
10912                         char boost_label[32];
10913
10914                         label = hda_get_autocfg_input_label(codec, cfg, i);
10915                         if (prev_label && !strcmp(label, prev_label))
10916                                 type_idx++;
10917                         else
10918                                 type_idx = 0;
10919                         prev_label = label;
10920
10921                         snprintf(boost_label, sizeof(boost_label),
10922                                  "%s Boost Volume", label);
10923                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10924                                           boost_label, type_idx,
10925                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10926                         if (err < 0)
10927                                 return err;
10928                 }
10929         }
10930         return 0;
10931 }
10932
10933 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
10934                                              const struct auto_pin_cfg *cfg);
10935
10936 /* almost identical with ALC880 parser... */
10937 static int alc882_parse_auto_config(struct hda_codec *codec)
10938 {
10939         struct alc_spec *spec = codec->spec;
10940         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10941         int err;
10942
10943         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10944                                            alc882_ignore);
10945         if (err < 0)
10946                 return err;
10947         if (!spec->autocfg.line_outs)
10948                 return 0; /* can't find valid BIOS pin config */
10949
10950         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10951         if (err < 0)
10952                 return err;
10953         if (codec->vendor_id == 0x10ec0887)
10954                 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
10955         else
10956                 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10957         if (err < 0)
10958                 return err;
10959         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10960                                            "Headphone");
10961         if (err < 0)
10962                 return err;
10963         err = alc880_auto_create_extra_out(spec,
10964                                            spec->autocfg.speaker_pins[0],
10965                                            "Speaker");
10966         if (err < 0)
10967                 return err;
10968         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10969         if (err < 0)
10970                 return err;
10971
10972         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10973
10974         alc_auto_parse_digital(codec);
10975
10976         if (spec->kctls.list)
10977                 add_mixer(spec, spec->kctls.list);
10978
10979         add_verb(spec, alc883_auto_init_verbs);
10980         /* if ADC 0x07 is available, initialize it, too */
10981         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10982                 add_verb(spec, alc882_adc1_init_verbs);
10983
10984         spec->num_mux_defs = 1;
10985         spec->input_mux = &spec->private_imux[0];
10986
10987         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10988
10989         err = alc_auto_add_mic_boost(codec);
10990         if (err < 0)
10991                 return err;
10992
10993         return 1; /* config found */
10994 }
10995
10996 /* additional initialization for auto-configuration model */
10997 static void alc882_auto_init(struct hda_codec *codec)
10998 {
10999         struct alc_spec *spec = codec->spec;
11000         alc882_auto_init_multi_out(codec);
11001         alc882_auto_init_hp_out(codec);
11002         alc882_auto_init_analog_input(codec);
11003         alc882_auto_init_input_src(codec);
11004         alc_auto_init_digital(codec);
11005         if (spec->unsol_event)
11006                 alc_inithook(codec);
11007 }
11008
11009 static int patch_alc882(struct hda_codec *codec)
11010 {
11011         struct alc_spec *spec;
11012         int err, board_config;
11013
11014         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11015         if (spec == NULL)
11016                 return -ENOMEM;
11017
11018         codec->spec = spec;
11019
11020         switch (codec->vendor_id) {
11021         case 0x10ec0882:
11022         case 0x10ec0885:
11023                 break;
11024         default:
11025                 /* ALC883 and variants */
11026                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11027                 break;
11028         }
11029
11030         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
11031                                                   alc882_models,
11032                                                   alc882_cfg_tbl);
11033
11034         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
11035                 board_config = snd_hda_check_board_codec_sid_config(codec,
11036                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
11037
11038         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
11039                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11040                        codec->chip_name);
11041                 board_config = ALC882_AUTO;
11042         }
11043
11044         if (board_config == ALC882_AUTO) {
11045                 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
11046                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
11047         }
11048
11049         alc_auto_parse_customize_define(codec);
11050
11051         if (board_config == ALC882_AUTO) {
11052                 /* automatic parse from the BIOS config */
11053                 err = alc882_parse_auto_config(codec);
11054                 if (err < 0) {
11055                         alc_free(codec);
11056                         return err;
11057                 } else if (!err) {
11058                         printk(KERN_INFO
11059                                "hda_codec: Cannot set up configuration "
11060                                "from BIOS.  Using base mode...\n");
11061                         board_config = ALC882_3ST_DIG;
11062                 }
11063         }
11064
11065         if (has_cdefine_beep(codec)) {
11066                 err = snd_hda_attach_beep_device(codec, 0x1);
11067                 if (err < 0) {
11068                         alc_free(codec);
11069                         return err;
11070                 }
11071         }
11072
11073         if (board_config != ALC882_AUTO)
11074                 setup_preset(codec, &alc882_presets[board_config]);
11075
11076         spec->stream_analog_playback = &alc882_pcm_analog_playback;
11077         spec->stream_analog_capture = &alc882_pcm_analog_capture;
11078         /* FIXME: setup DAC5 */
11079         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11080         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11081
11082         spec->stream_digital_playback = &alc882_pcm_digital_playback;
11083         spec->stream_digital_capture = &alc882_pcm_digital_capture;
11084
11085         if (!spec->adc_nids && spec->input_mux) {
11086                 int i, j;
11087                 spec->num_adc_nids = 0;
11088                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11089                         const struct hda_input_mux *imux = spec->input_mux;
11090                         hda_nid_t cap;
11091                         hda_nid_t items[16];
11092                         hda_nid_t nid = alc882_adc_nids[i];
11093                         unsigned int wcap = get_wcaps(codec, nid);
11094                         /* get type */
11095                         wcap = get_wcaps_type(wcap);
11096                         if (wcap != AC_WID_AUD_IN)
11097                                 continue;
11098                         spec->private_adc_nids[spec->num_adc_nids] = nid;
11099                         err = snd_hda_get_connections(codec, nid, &cap, 1);
11100                         if (err < 0)
11101                                 continue;
11102                         err = snd_hda_get_connections(codec, cap, items,
11103                                                       ARRAY_SIZE(items));
11104                         if (err < 0)
11105                                 continue;
11106                         for (j = 0; j < imux->num_items; j++)
11107                                 if (imux->items[j].index >= err)
11108                                         break;
11109                         if (j < imux->num_items)
11110                                 continue;
11111                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11112                         spec->num_adc_nids++;
11113                 }
11114                 spec->adc_nids = spec->private_adc_nids;
11115                 spec->capsrc_nids = spec->private_capsrc_nids;
11116         }
11117
11118         set_capture_mixer(codec);
11119
11120         if (has_cdefine_beep(codec))
11121                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11122
11123         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
11124
11125         spec->vmaster_nid = 0x0c;
11126
11127         codec->patch_ops = alc_patch_ops;
11128         if (board_config == ALC882_AUTO)
11129                 spec->init_hook = alc882_auto_init;
11130
11131         alc_init_jacks(codec);
11132 #ifdef CONFIG_SND_HDA_POWER_SAVE
11133         if (!spec->loopback.amplist)
11134                 spec->loopback.amplist = alc882_loopbacks;
11135 #endif
11136
11137         return 0;
11138 }
11139
11140
11141 /*
11142  * ALC262 support
11143  */
11144
11145 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
11146 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
11147
11148 #define alc262_dac_nids         alc260_dac_nids
11149 #define alc262_adc_nids         alc882_adc_nids
11150 #define alc262_adc_nids_alt     alc882_adc_nids_alt
11151 #define alc262_capsrc_nids      alc882_capsrc_nids
11152 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
11153
11154 #define alc262_modes            alc260_modes
11155 #define alc262_capture_source   alc882_capture_source
11156
11157 static hda_nid_t alc262_dmic_adc_nids[1] = {
11158         /* ADC0 */
11159         0x09
11160 };
11161
11162 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11163
11164 static struct snd_kcontrol_new alc262_base_mixer[] = {
11165         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11166         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11167         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11168         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11169         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11170         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11171         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11172         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11173         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11174         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11175         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11176         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11177         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11178         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11179         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11180         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11181         { } /* end */
11182 };
11183
11184 /* update HP, line and mono-out pins according to the master switch */
11185 static void alc262_hp_master_update(struct hda_codec *codec)
11186 {
11187         struct alc_spec *spec = codec->spec;
11188         int val = spec->master_sw;
11189
11190         /* HP & line-out */
11191         snd_hda_codec_write_cache(codec, 0x1b, 0,
11192                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11193                                   val ? PIN_HP : 0);
11194         snd_hda_codec_write_cache(codec, 0x15, 0,
11195                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11196                                   val ? PIN_HP : 0);
11197         /* mono (speaker) depending on the HP jack sense */
11198         val = val && !spec->jack_present;
11199         snd_hda_codec_write_cache(codec, 0x16, 0,
11200                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11201                                   val ? PIN_OUT : 0);
11202 }
11203
11204 static void alc262_hp_bpc_automute(struct hda_codec *codec)
11205 {
11206         struct alc_spec *spec = codec->spec;
11207
11208         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11209         alc262_hp_master_update(codec);
11210 }
11211
11212 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11213 {
11214         if ((res >> 26) != ALC880_HP_EVENT)
11215                 return;
11216         alc262_hp_bpc_automute(codec);
11217 }
11218
11219 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11220 {
11221         struct alc_spec *spec = codec->spec;
11222
11223         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11224         alc262_hp_master_update(codec);
11225 }
11226
11227 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11228                                            unsigned int res)
11229 {
11230         if ((res >> 26) != ALC880_HP_EVENT)
11231                 return;
11232         alc262_hp_wildwest_automute(codec);
11233 }
11234
11235 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11236
11237 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11238                                    struct snd_ctl_elem_value *ucontrol)
11239 {
11240         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11241         struct alc_spec *spec = codec->spec;
11242         int val = !!*ucontrol->value.integer.value;
11243
11244         if (val == spec->master_sw)
11245                 return 0;
11246         spec->master_sw = val;
11247         alc262_hp_master_update(codec);
11248         return 1;
11249 }
11250
11251 #define ALC262_HP_MASTER_SWITCH                                 \
11252         {                                                       \
11253                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11254                 .name = "Master Playback Switch",               \
11255                 .info = snd_ctl_boolean_mono_info,              \
11256                 .get = alc262_hp_master_sw_get,                 \
11257                 .put = alc262_hp_master_sw_put,                 \
11258         }, \
11259         {                                                       \
11260                 .iface = NID_MAPPING,                           \
11261                 .name = "Master Playback Switch",               \
11262                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11263         }
11264
11265
11266 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11267         ALC262_HP_MASTER_SWITCH,
11268         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11269         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11270         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11271         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11272                               HDA_OUTPUT),
11273         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11274                             HDA_OUTPUT),
11275         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11276         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11277         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11278         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11279         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11280         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11281         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11282         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11283         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11284         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11285         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11286         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11287         { } /* end */
11288 };
11289
11290 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11291         ALC262_HP_MASTER_SWITCH,
11292         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11293         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11294         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11295         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11296         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11297                               HDA_OUTPUT),
11298         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11299                             HDA_OUTPUT),
11300         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11301         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11302         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT),
11303         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11304         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11305         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11306         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11307         { } /* end */
11308 };
11309
11310 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11311         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11312         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11313         HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT),
11314         { } /* end */
11315 };
11316
11317 /* mute/unmute internal speaker according to the hp jack and mute state */
11318 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11319 {
11320         struct alc_spec *spec = codec->spec;
11321
11322         spec->autocfg.hp_pins[0] = 0x15;
11323         spec->autocfg.speaker_pins[0] = 0x14;
11324 }
11325
11326 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11327         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11328         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11329         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11330         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11331         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11332         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11333         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11334         { } /* end */
11335 };
11336
11337 static struct hda_verb alc262_hp_t5735_verbs[] = {
11338         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11339         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11340
11341         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11342         { }
11343 };
11344
11345 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11346         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11347         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11348         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11349         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11350         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11351         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11352         { } /* end */
11353 };
11354
11355 static struct hda_verb alc262_hp_rp5700_verbs[] = {
11356         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11357         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11358         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11359         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11360         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11361         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11362         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11363         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11364         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11365         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11366         {}
11367 };
11368
11369 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11370         .num_items = 1,
11371         .items = {
11372                 { "Line", 0x1 },
11373         },
11374 };
11375
11376 /* bind hp and internal speaker mute (with plug check) as master switch */
11377 static void alc262_hippo_master_update(struct hda_codec *codec)
11378 {
11379         struct alc_spec *spec = codec->spec;
11380         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11381         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11382         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11383         unsigned int mute;
11384
11385         /* HP */
11386         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11387         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11388                                  HDA_AMP_MUTE, mute);
11389         /* mute internal speaker per jack sense */
11390         if (spec->jack_present)
11391                 mute = HDA_AMP_MUTE;
11392         if (line_nid)
11393                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11394                                          HDA_AMP_MUTE, mute);
11395         if (speaker_nid && speaker_nid != line_nid)
11396                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11397                                          HDA_AMP_MUTE, mute);
11398 }
11399
11400 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11401
11402 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11403                                       struct snd_ctl_elem_value *ucontrol)
11404 {
11405         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11406         struct alc_spec *spec = codec->spec;
11407         int val = !!*ucontrol->value.integer.value;
11408
11409         if (val == spec->master_sw)
11410                 return 0;
11411         spec->master_sw = val;
11412         alc262_hippo_master_update(codec);
11413         return 1;
11414 }
11415
11416 #define ALC262_HIPPO_MASTER_SWITCH                              \
11417         {                                                       \
11418                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11419                 .name = "Master Playback Switch",               \
11420                 .info = snd_ctl_boolean_mono_info,              \
11421                 .get = alc262_hippo_master_sw_get,              \
11422                 .put = alc262_hippo_master_sw_put,              \
11423         },                                                      \
11424         {                                                       \
11425                 .iface = NID_MAPPING,                           \
11426                 .name = "Master Playback Switch",               \
11427                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11428                              (SUBDEV_SPEAKER(0) << 16), \
11429         }
11430
11431 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11432         ALC262_HIPPO_MASTER_SWITCH,
11433         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11434         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11435         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11436         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11437         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11438         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11439         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11440         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11441         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11442         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11443         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11444         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11445         { } /* end */
11446 };
11447
11448 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11449         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11450         ALC262_HIPPO_MASTER_SWITCH,
11451         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11452         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11453         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11454         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11455         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11456         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11457         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11458         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11459         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11460         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11461         { } /* end */
11462 };
11463
11464 /* mute/unmute internal speaker according to the hp jack and mute state */
11465 static void alc262_hippo_automute(struct hda_codec *codec)
11466 {
11467         struct alc_spec *spec = codec->spec;
11468         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11469
11470         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11471         alc262_hippo_master_update(codec);
11472 }
11473
11474 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11475 {
11476         if ((res >> 26) != ALC880_HP_EVENT)
11477                 return;
11478         alc262_hippo_automute(codec);
11479 }
11480
11481 static void alc262_hippo_setup(struct hda_codec *codec)
11482 {
11483         struct alc_spec *spec = codec->spec;
11484
11485         spec->autocfg.hp_pins[0] = 0x15;
11486         spec->autocfg.speaker_pins[0] = 0x14;
11487 }
11488
11489 static void alc262_hippo1_setup(struct hda_codec *codec)
11490 {
11491         struct alc_spec *spec = codec->spec;
11492
11493         spec->autocfg.hp_pins[0] = 0x1b;
11494         spec->autocfg.speaker_pins[0] = 0x14;
11495 }
11496
11497
11498 static struct snd_kcontrol_new alc262_sony_mixer[] = {
11499         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11500         ALC262_HIPPO_MASTER_SWITCH,
11501         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11502         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11503         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11504         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11505         { } /* end */
11506 };
11507
11508 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11509         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11510         ALC262_HIPPO_MASTER_SWITCH,
11511         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11512         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11513         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11514         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11515         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11516         { } /* end */
11517 };
11518
11519 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11520         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11521         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11522         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11523         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11524         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11525         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11526         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11527         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11528         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11529         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11530         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11531         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11532         { } /* end */
11533 };
11534
11535 static struct hda_verb alc262_tyan_verbs[] = {
11536         /* Headphone automute */
11537         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11538         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11539         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11540
11541         /* P11 AUX_IN, white 4-pin connector */
11542         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11543         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11544         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11545         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11546
11547         {}
11548 };
11549
11550 /* unsolicited event for HP jack sensing */
11551 static void alc262_tyan_setup(struct hda_codec *codec)
11552 {
11553         struct alc_spec *spec = codec->spec;
11554
11555         spec->autocfg.hp_pins[0] = 0x1b;
11556         spec->autocfg.speaker_pins[0] = 0x15;
11557 }
11558
11559
11560 #define alc262_capture_mixer            alc882_capture_mixer
11561 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11562
11563 /*
11564  * generic initialization of ADC, input mixers and output mixers
11565  */
11566 static struct hda_verb alc262_init_verbs[] = {
11567         /*
11568          * Unmute ADC0-2 and set the default input to mic-in
11569          */
11570         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11571         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11572         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11573         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11574         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11575         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11576
11577         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11578          * mixer widget
11579          * Note: PASD motherboards uses the Line In 2 as the input for
11580          * front panel mic (mic 2)
11581          */
11582         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11583         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11584         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11585         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11586         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11587         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11588
11589         /*
11590          * Set up output mixers (0x0c - 0x0e)
11591          */
11592         /* set vol=0 to output mixers */
11593         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11594         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11595         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11596         /* set up input amps for analog loopback */
11597         /* Amp Indices: DAC = 0, mixer = 1 */
11598         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11599         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11600         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11601         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11602         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11603         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11604
11605         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11606         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11607         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11608         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11609         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11610         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11611
11612         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11613         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11614         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11615         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11616         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11617
11618         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11619         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11620
11621         /* FIXME: use matrix-type input source selection */
11622         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11623         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11624         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11625         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11626         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11627         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11628         /* Input mixer2 */
11629         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11630         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11631         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11632         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11633         /* Input mixer3 */
11634         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11635         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11636         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11637         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11638
11639         { }
11640 };
11641
11642 static struct hda_verb alc262_eapd_verbs[] = {
11643         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11644         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11645         { }
11646 };
11647
11648 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11649         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11650         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11651         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11652
11653         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11654         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11655         {}
11656 };
11657
11658 static struct hda_verb alc262_sony_unsol_verbs[] = {
11659         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11660         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11661         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11662
11663         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11664         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11665         {}
11666 };
11667
11668 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11669         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11670         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11671         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11672         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11673         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11674         { } /* end */
11675 };
11676
11677 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11678         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11679         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11680         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11681         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11682         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11683         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11684         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11685         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11686         {}
11687 };
11688
11689 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11690 {
11691         struct alc_spec *spec = codec->spec;
11692
11693         spec->autocfg.hp_pins[0] = 0x15;
11694         spec->autocfg.speaker_pins[0] = 0x14;
11695         spec->ext_mic.pin = 0x18;
11696         spec->ext_mic.mux_idx = 0;
11697         spec->int_mic.pin = 0x12;
11698         spec->int_mic.mux_idx = 9;
11699         spec->auto_mic = 1;
11700 }
11701
11702 /*
11703  * nec model
11704  *  0x15 = headphone
11705  *  0x16 = internal speaker
11706  *  0x18 = external mic
11707  */
11708
11709 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11710         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11711         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11712
11713         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11714         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11715         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11716
11717         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11718         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11719         { } /* end */
11720 };
11721
11722 static struct hda_verb alc262_nec_verbs[] = {
11723         /* Unmute Speaker */
11724         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11725
11726         /* Headphone */
11727         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11728         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11729
11730         /* External mic to headphone */
11731         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11732         /* External mic to speaker */
11733         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11734         {}
11735 };
11736
11737 /*
11738  * fujitsu model
11739  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11740  *  0x1b = port replicator headphone out
11741  */
11742
11743 #define ALC_HP_EVENT    0x37
11744
11745 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11746         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11747         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11748         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11749         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11750         {}
11751 };
11752
11753 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11754         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11755         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11756         {}
11757 };
11758
11759 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11760         /* Front Mic pin: input vref at 50% */
11761         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11762         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11763         {}
11764 };
11765
11766 static struct hda_input_mux alc262_fujitsu_capture_source = {
11767         .num_items = 3,
11768         .items = {
11769                 { "Mic", 0x0 },
11770                 { "Internal Mic", 0x1 },
11771                 { "CD", 0x4 },
11772         },
11773 };
11774
11775 static struct hda_input_mux alc262_HP_capture_source = {
11776         .num_items = 5,
11777         .items = {
11778                 { "Mic", 0x0 },
11779                 { "Front Mic", 0x1 },
11780                 { "Line", 0x2 },
11781                 { "CD", 0x4 },
11782                 { "AUX IN", 0x6 },
11783         },
11784 };
11785
11786 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11787         .num_items = 4,
11788         .items = {
11789                 { "Mic", 0x0 },
11790                 { "Front Mic", 0x2 },
11791                 { "Line", 0x1 },
11792                 { "CD", 0x4 },
11793         },
11794 };
11795
11796 /* mute/unmute internal speaker according to the hp jacks and mute state */
11797 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11798 {
11799         struct alc_spec *spec = codec->spec;
11800         unsigned int mute;
11801
11802         if (force || !spec->sense_updated) {
11803                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11804                                      snd_hda_jack_detect(codec, 0x1b);
11805                 spec->sense_updated = 1;
11806         }
11807         /* unmute internal speaker only if both HPs are unplugged and
11808          * master switch is on
11809          */
11810         if (spec->jack_present)
11811                 mute = HDA_AMP_MUTE;
11812         else
11813                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11814         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11815                                  HDA_AMP_MUTE, mute);
11816 }
11817
11818 /* unsolicited event for HP jack sensing */
11819 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11820                                        unsigned int res)
11821 {
11822         if ((res >> 26) != ALC_HP_EVENT)
11823                 return;
11824         alc262_fujitsu_automute(codec, 1);
11825 }
11826
11827 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11828 {
11829         alc262_fujitsu_automute(codec, 1);
11830 }
11831
11832 /* bind volumes of both NID 0x0c and 0x0d */
11833 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11834         .ops = &snd_hda_bind_vol,
11835         .values = {
11836                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11837                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11838                 0
11839         },
11840 };
11841
11842 /* mute/unmute internal speaker according to the hp jack and mute state */
11843 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11844 {
11845         struct alc_spec *spec = codec->spec;
11846         unsigned int mute;
11847
11848         if (force || !spec->sense_updated) {
11849                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11850                 spec->sense_updated = 1;
11851         }
11852         if (spec->jack_present) {
11853                 /* mute internal speaker */
11854                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11855                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11856                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11857                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11858         } else {
11859                 /* unmute internal speaker if necessary */
11860                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11861                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11862                                          HDA_AMP_MUTE, mute);
11863                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11864                                          HDA_AMP_MUTE, mute);
11865         }
11866 }
11867
11868 /* unsolicited event for HP jack sensing */
11869 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11870                                        unsigned int res)
11871 {
11872         if ((res >> 26) != ALC_HP_EVENT)
11873                 return;
11874         alc262_lenovo_3000_automute(codec, 1);
11875 }
11876
11877 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11878                                   int dir, int idx, long *valp)
11879 {
11880         int i, change = 0;
11881
11882         for (i = 0; i < 2; i++, valp++)
11883                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11884                                                    HDA_AMP_MUTE,
11885                                                    *valp ? 0 : HDA_AMP_MUTE);
11886         return change;
11887 }
11888
11889 /* bind hp and internal speaker mute (with plug check) */
11890 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11891                                          struct snd_ctl_elem_value *ucontrol)
11892 {
11893         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11894         long *valp = ucontrol->value.integer.value;
11895         int change;
11896
11897         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11898         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11899         if (change)
11900                 alc262_fujitsu_automute(codec, 0);
11901         return change;
11902 }
11903
11904 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11905         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11906         {
11907                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11908                 .name = "Master Playback Switch",
11909                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11910                 .info = snd_hda_mixer_amp_switch_info,
11911                 .get = snd_hda_mixer_amp_switch_get,
11912                 .put = alc262_fujitsu_master_sw_put,
11913                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11914         },
11915         {
11916                 .iface = NID_MAPPING,
11917                 .name = "Master Playback Switch",
11918                 .private_value = 0x1b,
11919         },
11920         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11921         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11922         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11923         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11924         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11925         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11926         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11927         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11928         { } /* end */
11929 };
11930
11931 /* bind hp and internal speaker mute (with plug check) */
11932 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11933                                          struct snd_ctl_elem_value *ucontrol)
11934 {
11935         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11936         long *valp = ucontrol->value.integer.value;
11937         int change;
11938
11939         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11940         if (change)
11941                 alc262_lenovo_3000_automute(codec, 0);
11942         return change;
11943 }
11944
11945 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11946         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11947         {
11948                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11949                 .name = "Master Playback Switch",
11950                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11951                 .info = snd_hda_mixer_amp_switch_info,
11952                 .get = snd_hda_mixer_amp_switch_get,
11953                 .put = alc262_lenovo_3000_master_sw_put,
11954                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11955         },
11956         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11957         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11958         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11959         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11960         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11961         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11962         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11963         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11964         { } /* end */
11965 };
11966
11967 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11968         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11969         ALC262_HIPPO_MASTER_SWITCH,
11970         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11971         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11972         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11973         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11974         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11975         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11976         { } /* end */
11977 };
11978
11979 /* additional init verbs for Benq laptops */
11980 static struct hda_verb alc262_EAPD_verbs[] = {
11981         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11982         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11983         {}
11984 };
11985
11986 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11987         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11988         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11989
11990         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11991         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11992         {}
11993 };
11994
11995 /* Samsung Q1 Ultra Vista model setup */
11996 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11997         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11998         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11999         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12000         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12001         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
12002         HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
12003         { } /* end */
12004 };
12005
12006 static struct hda_verb alc262_ultra_verbs[] = {
12007         /* output mixer */
12008         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12009         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12010         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12011         /* speaker */
12012         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12013         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12014         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12015         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12016         /* HP */
12017         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12018         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12019         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12020         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12021         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12022         /* internal mic */
12023         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12024         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12025         /* ADC, choose mic */
12026         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12027         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12028         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12029         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12030         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12031         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12032         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12033         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12034         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12035         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
12036         {}
12037 };
12038
12039 /* mute/unmute internal speaker according to the hp jack and mute state */
12040 static void alc262_ultra_automute(struct hda_codec *codec)
12041 {
12042         struct alc_spec *spec = codec->spec;
12043         unsigned int mute;
12044
12045         mute = 0;
12046         /* auto-mute only when HP is used as HP */
12047         if (!spec->cur_mux[0]) {
12048                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
12049                 if (spec->jack_present)
12050                         mute = HDA_AMP_MUTE;
12051         }
12052         /* mute/unmute internal speaker */
12053         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12054                                  HDA_AMP_MUTE, mute);
12055         /* mute/unmute HP */
12056         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12057                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
12058 }
12059
12060 /* unsolicited event for HP jack sensing */
12061 static void alc262_ultra_unsol_event(struct hda_codec *codec,
12062                                        unsigned int res)
12063 {
12064         if ((res >> 26) != ALC880_HP_EVENT)
12065                 return;
12066         alc262_ultra_automute(codec);
12067 }
12068
12069 static struct hda_input_mux alc262_ultra_capture_source = {
12070         .num_items = 2,
12071         .items = {
12072                 { "Mic", 0x1 },
12073                 { "Headphone", 0x7 },
12074         },
12075 };
12076
12077 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
12078                                      struct snd_ctl_elem_value *ucontrol)
12079 {
12080         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12081         struct alc_spec *spec = codec->spec;
12082         int ret;
12083
12084         ret = alc_mux_enum_put(kcontrol, ucontrol);
12085         if (!ret)
12086                 return 0;
12087         /* reprogram the HP pin as mic or HP according to the input source */
12088         snd_hda_codec_write_cache(codec, 0x15, 0,
12089                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
12090                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12091         alc262_ultra_automute(codec); /* mute/unmute HP */
12092         return ret;
12093 }
12094
12095 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12096         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12097         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12098         {
12099                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12100                 .name = "Capture Source",
12101                 .info = alc_mux_enum_info,
12102                 .get = alc_mux_enum_get,
12103                 .put = alc262_ultra_mux_enum_put,
12104         },
12105         {
12106                 .iface = NID_MAPPING,
12107                 .name = "Capture Source",
12108                 .private_value = 0x15,
12109         },
12110         { } /* end */
12111 };
12112
12113 /* We use two mixers depending on the output pin; 0x16 is a mono output
12114  * and thus it's bound with a different mixer.
12115  * This function returns which mixer amp should be used.
12116  */
12117 static int alc262_check_volbit(hda_nid_t nid)
12118 {
12119         if (!nid)
12120                 return 0;
12121         else if (nid == 0x16)
12122                 return 2;
12123         else
12124                 return 1;
12125 }
12126
12127 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12128                                   const char *pfx, int *vbits, int idx)
12129 {
12130         unsigned long val;
12131         int vbit;
12132
12133         vbit = alc262_check_volbit(nid);
12134         if (!vbit)
12135                 return 0;
12136         if (*vbits & vbit) /* a volume control for this mixer already there */
12137                 return 0;
12138         *vbits |= vbit;
12139         if (vbit == 2)
12140                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12141         else
12142                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12143         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12144 }
12145
12146 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12147                                  const char *pfx, int idx)
12148 {
12149         unsigned long val;
12150
12151         if (!nid)
12152                 return 0;
12153         if (nid == 0x16)
12154                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12155         else
12156                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12157         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12158 }
12159
12160 /* add playback controls from the parsed DAC table */
12161 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12162                                              const struct auto_pin_cfg *cfg)
12163 {
12164         const char *pfx;
12165         int vbits;
12166         int i, err;
12167
12168         spec->multiout.num_dacs = 1;    /* only use one dac */
12169         spec->multiout.dac_nids = spec->private_dac_nids;
12170         spec->multiout.dac_nids[0] = 2;
12171
12172         pfx = alc_get_line_out_pfx(cfg, true);
12173         if (!pfx)
12174                 pfx = "Front";
12175         for (i = 0; i < 2; i++) {
12176                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12177                 if (err < 0)
12178                         return err;
12179                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12180                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12181                                                     "Speaker", i);
12182                         if (err < 0)
12183                                 return err;
12184                 }
12185                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12186                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12187                                                     "Headphone", i);
12188                         if (err < 0)
12189                                 return err;
12190                 }
12191         }
12192
12193         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12194                 alc262_check_volbit(cfg->speaker_pins[0]) |
12195                 alc262_check_volbit(cfg->hp_pins[0]);
12196         if (vbits == 1 || vbits == 2)
12197                 pfx = "Master"; /* only one mixer is used */
12198         vbits = 0;
12199         for (i = 0; i < 2; i++) {
12200                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12201                                              &vbits, i);
12202                 if (err < 0)
12203                         return err;
12204                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12205                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12206                                                      "Speaker", &vbits, i);
12207                         if (err < 0)
12208                                 return err;
12209                 }
12210                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12211                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12212                                                      "Headphone", &vbits, i);
12213                         if (err < 0)
12214                                 return err;
12215                 }
12216         }
12217         return 0;
12218 }
12219
12220 #define alc262_auto_create_input_ctls \
12221         alc882_auto_create_input_ctls
12222
12223 /*
12224  * generic initialization of ADC, input mixers and output mixers
12225  */
12226 static struct hda_verb alc262_volume_init_verbs[] = {
12227         /*
12228          * Unmute ADC0-2 and set the default input to mic-in
12229          */
12230         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12231         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12232         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12233         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12234         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12235         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12236
12237         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12238          * mixer widget
12239          * Note: PASD motherboards uses the Line In 2 as the input for
12240          * front panel mic (mic 2)
12241          */
12242         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12243         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12244         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12245         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12246         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12247         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12248
12249         /*
12250          * Set up output mixers (0x0c - 0x0f)
12251          */
12252         /* set vol=0 to output mixers */
12253         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12254         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12255         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12256
12257         /* set up input amps for analog loopback */
12258         /* Amp Indices: DAC = 0, mixer = 1 */
12259         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12260         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12261         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12262         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12263         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12264         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12265
12266         /* FIXME: use matrix-type input source selection */
12267         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12268         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12269         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12270         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12271         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12272         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12273         /* Input mixer2 */
12274         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12275         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12276         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12277         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12278         /* Input mixer3 */
12279         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12280         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12281         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12282         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12283
12284         { }
12285 };
12286
12287 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12288         /*
12289          * Unmute ADC0-2 and set the default input to mic-in
12290          */
12291         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12292         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12293         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12294         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12295         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12296         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12297
12298         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12299          * mixer widget
12300          * Note: PASD motherboards uses the Line In 2 as the input for
12301          * front panel mic (mic 2)
12302          */
12303         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12304         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12305         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12306         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12307         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12308         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12309         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12310         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12311
12312         /*
12313          * Set up output mixers (0x0c - 0x0e)
12314          */
12315         /* set vol=0 to output mixers */
12316         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12317         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12318         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12319
12320         /* set up input amps for analog loopback */
12321         /* Amp Indices: DAC = 0, mixer = 1 */
12322         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12323         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12324         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12325         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12326         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12327         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12328
12329         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12330         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12331         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12332
12333         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12334         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12335
12336         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12337         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12338
12339         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12340         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12341         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12342         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12343         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12344
12345         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12346         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12347         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12348         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12349         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12350         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12351
12352
12353         /* FIXME: use matrix-type input source selection */
12354         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12355         /* Input mixer1: only unmute Mic */
12356         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12357         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12358         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12359         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12360         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12361         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12362         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12363         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12364         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12365         /* Input mixer2 */
12366         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12367         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12368         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12369         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12370         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12371         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12372         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12373         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12374         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12375         /* Input mixer3 */
12376         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12377         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12378         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12379         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12380         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12381         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12382         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12383         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12384         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12385
12386         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12387
12388         { }
12389 };
12390
12391 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12392         /*
12393          * Unmute ADC0-2 and set the default input to mic-in
12394          */
12395         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12396         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12397         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12398         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12399         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12400         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12401
12402         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12403          * mixer widget
12404          * Note: PASD motherboards uses the Line In 2 as the input for front
12405          * panel mic (mic 2)
12406          */
12407         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12408         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12409         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12410         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12411         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12412         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12413         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12414         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12415         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12416         /*
12417          * Set up output mixers (0x0c - 0x0e)
12418          */
12419         /* set vol=0 to output mixers */
12420         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12421         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12422         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12423
12424         /* set up input amps for analog loopback */
12425         /* Amp Indices: DAC = 0, mixer = 1 */
12426         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12427         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12428         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12429         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12430         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12431         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12432
12433
12434         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12435         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12436         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12437         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12438         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12439         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12440         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12441
12442         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12443         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12444
12445         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12446         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12447
12448         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12449         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12450         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12451         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12452         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12453         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12454
12455         /* FIXME: use matrix-type input source selection */
12456         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12457         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12458         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12459         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12460         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12461         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12462         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12463         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12464         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12465         /* Input mixer2 */
12466         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12467         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12468         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12469         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12470         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12471         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12472         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12473         /* Input mixer3 */
12474         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12475         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12476         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12477         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12478         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12479         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12480         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12481
12482         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12483
12484         { }
12485 };
12486
12487 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12488
12489         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12490         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12491         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12492
12493         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12494         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12495         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12496         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12497
12498         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12499         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12500         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12501         {}
12502 };
12503
12504 /*
12505  * Pin config fixes
12506  */
12507 enum {
12508         PINFIX_FSC_H270,
12509 };
12510
12511 static const struct alc_fixup alc262_fixups[] = {
12512         [PINFIX_FSC_H270] = {
12513                 .type = ALC_FIXUP_PINS,
12514                 .v.pins = (const struct alc_pincfg[]) {
12515                         { 0x14, 0x99130110 }, /* speaker */
12516                         { 0x15, 0x0221142f }, /* front HP */
12517                         { 0x1b, 0x0121141f }, /* rear HP */
12518                         { }
12519                 }
12520         },
12521 };
12522
12523 static struct snd_pci_quirk alc262_fixup_tbl[] = {
12524         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12525         {}
12526 };
12527
12528
12529 #ifdef CONFIG_SND_HDA_POWER_SAVE
12530 #define alc262_loopbacks        alc880_loopbacks
12531 #endif
12532
12533 /* pcm configuration: identical with ALC880 */
12534 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12535 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12536 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12537 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12538
12539 /*
12540  * BIOS auto configuration
12541  */
12542 static int alc262_parse_auto_config(struct hda_codec *codec)
12543 {
12544         struct alc_spec *spec = codec->spec;
12545         int err;
12546         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12547
12548         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12549                                            alc262_ignore);
12550         if (err < 0)
12551                 return err;
12552         if (!spec->autocfg.line_outs) {
12553                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12554                         spec->multiout.max_channels = 2;
12555                         spec->no_analog = 1;
12556                         goto dig_only;
12557                 }
12558                 return 0; /* can't find valid BIOS pin config */
12559         }
12560         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12561         if (err < 0)
12562                 return err;
12563         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12564         if (err < 0)
12565                 return err;
12566
12567         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12568
12569  dig_only:
12570         alc_auto_parse_digital(codec);
12571
12572         if (spec->kctls.list)
12573                 add_mixer(spec, spec->kctls.list);
12574
12575         add_verb(spec, alc262_volume_init_verbs);
12576         spec->num_mux_defs = 1;
12577         spec->input_mux = &spec->private_imux[0];
12578
12579         err = alc_auto_add_mic_boost(codec);
12580         if (err < 0)
12581                 return err;
12582
12583         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12584
12585         return 1;
12586 }
12587
12588 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12589 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12590 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12591 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12592
12593
12594 /* init callback for auto-configuration model -- overriding the default init */
12595 static void alc262_auto_init(struct hda_codec *codec)
12596 {
12597         struct alc_spec *spec = codec->spec;
12598         alc262_auto_init_multi_out(codec);
12599         alc262_auto_init_hp_out(codec);
12600         alc262_auto_init_analog_input(codec);
12601         alc262_auto_init_input_src(codec);
12602         alc_auto_init_digital(codec);
12603         if (spec->unsol_event)
12604                 alc_inithook(codec);
12605 }
12606
12607 /*
12608  * configuration and preset
12609  */
12610 static const char * const alc262_models[ALC262_MODEL_LAST] = {
12611         [ALC262_BASIC]          = "basic",
12612         [ALC262_HIPPO]          = "hippo",
12613         [ALC262_HIPPO_1]        = "hippo_1",
12614         [ALC262_FUJITSU]        = "fujitsu",
12615         [ALC262_HP_BPC]         = "hp-bpc",
12616         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12617         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12618         [ALC262_HP_RP5700]      = "hp-rp5700",
12619         [ALC262_BENQ_ED8]       = "benq",
12620         [ALC262_BENQ_T31]       = "benq-t31",
12621         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12622         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12623         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12624         [ALC262_ULTRA]          = "ultra",
12625         [ALC262_LENOVO_3000]    = "lenovo-3000",
12626         [ALC262_NEC]            = "nec",
12627         [ALC262_TYAN]           = "tyan",
12628         [ALC262_AUTO]           = "auto",
12629 };
12630
12631 static struct snd_pci_quirk alc262_cfg_tbl[] = {
12632         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12633         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12634         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12635                            ALC262_HP_BPC),
12636         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12637                            ALC262_HP_BPC),
12638         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12639                            ALC262_HP_BPC),
12640         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12641         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12642         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12643         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12644         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12645         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12646         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12647         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12648         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12649         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12650         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12651         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12652                       ALC262_HP_TC_T5735),
12653         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12654         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12655         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12656         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12657         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12658         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12659         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12660         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12661 #if 0 /* disable the quirk since model=auto works better in recent versions */
12662         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12663                            ALC262_SONY_ASSAMD),
12664 #endif
12665         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12666                       ALC262_TOSHIBA_RX1),
12667         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12668         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12669         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12670         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12671         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12672                            ALC262_ULTRA),
12673         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12674         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12675         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12676         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12677         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12678         {}
12679 };
12680
12681 static struct alc_config_preset alc262_presets[] = {
12682         [ALC262_BASIC] = {
12683                 .mixers = { alc262_base_mixer },
12684                 .init_verbs = { alc262_init_verbs },
12685                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12686                 .dac_nids = alc262_dac_nids,
12687                 .hp_nid = 0x03,
12688                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12689                 .channel_mode = alc262_modes,
12690                 .input_mux = &alc262_capture_source,
12691         },
12692         [ALC262_HIPPO] = {
12693                 .mixers = { alc262_hippo_mixer },
12694                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12695                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12696                 .dac_nids = alc262_dac_nids,
12697                 .hp_nid = 0x03,
12698                 .dig_out_nid = ALC262_DIGOUT_NID,
12699                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12700                 .channel_mode = alc262_modes,
12701                 .input_mux = &alc262_capture_source,
12702                 .unsol_event = alc262_hippo_unsol_event,
12703                 .setup = alc262_hippo_setup,
12704                 .init_hook = alc262_hippo_automute,
12705         },
12706         [ALC262_HIPPO_1] = {
12707                 .mixers = { alc262_hippo1_mixer },
12708                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12709                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12710                 .dac_nids = alc262_dac_nids,
12711                 .hp_nid = 0x02,
12712                 .dig_out_nid = ALC262_DIGOUT_NID,
12713                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12714                 .channel_mode = alc262_modes,
12715                 .input_mux = &alc262_capture_source,
12716                 .unsol_event = alc262_hippo_unsol_event,
12717                 .setup = alc262_hippo1_setup,
12718                 .init_hook = alc262_hippo_automute,
12719         },
12720         [ALC262_FUJITSU] = {
12721                 .mixers = { alc262_fujitsu_mixer },
12722                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12723                                 alc262_fujitsu_unsol_verbs },
12724                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12725                 .dac_nids = alc262_dac_nids,
12726                 .hp_nid = 0x03,
12727                 .dig_out_nid = ALC262_DIGOUT_NID,
12728                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12729                 .channel_mode = alc262_modes,
12730                 .input_mux = &alc262_fujitsu_capture_source,
12731                 .unsol_event = alc262_fujitsu_unsol_event,
12732                 .init_hook = alc262_fujitsu_init_hook,
12733         },
12734         [ALC262_HP_BPC] = {
12735                 .mixers = { alc262_HP_BPC_mixer },
12736                 .init_verbs = { alc262_HP_BPC_init_verbs },
12737                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12738                 .dac_nids = alc262_dac_nids,
12739                 .hp_nid = 0x03,
12740                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12741                 .channel_mode = alc262_modes,
12742                 .input_mux = &alc262_HP_capture_source,
12743                 .unsol_event = alc262_hp_bpc_unsol_event,
12744                 .init_hook = alc262_hp_bpc_automute,
12745         },
12746         [ALC262_HP_BPC_D7000_WF] = {
12747                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12748                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12749                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12750                 .dac_nids = alc262_dac_nids,
12751                 .hp_nid = 0x03,
12752                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12753                 .channel_mode = alc262_modes,
12754                 .input_mux = &alc262_HP_D7000_capture_source,
12755                 .unsol_event = alc262_hp_wildwest_unsol_event,
12756                 .init_hook = alc262_hp_wildwest_automute,
12757         },
12758         [ALC262_HP_BPC_D7000_WL] = {
12759                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12760                             alc262_HP_BPC_WildWest_option_mixer },
12761                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12762                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12763                 .dac_nids = alc262_dac_nids,
12764                 .hp_nid = 0x03,
12765                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12766                 .channel_mode = alc262_modes,
12767                 .input_mux = &alc262_HP_D7000_capture_source,
12768                 .unsol_event = alc262_hp_wildwest_unsol_event,
12769                 .init_hook = alc262_hp_wildwest_automute,
12770         },
12771         [ALC262_HP_TC_T5735] = {
12772                 .mixers = { alc262_hp_t5735_mixer },
12773                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12774                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12775                 .dac_nids = alc262_dac_nids,
12776                 .hp_nid = 0x03,
12777                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12778                 .channel_mode = alc262_modes,
12779                 .input_mux = &alc262_capture_source,
12780                 .unsol_event = alc_sku_unsol_event,
12781                 .setup = alc262_hp_t5735_setup,
12782                 .init_hook = alc_inithook,
12783         },
12784         [ALC262_HP_RP5700] = {
12785                 .mixers = { alc262_hp_rp5700_mixer },
12786                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12787                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12788                 .dac_nids = alc262_dac_nids,
12789                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12790                 .channel_mode = alc262_modes,
12791                 .input_mux = &alc262_hp_rp5700_capture_source,
12792         },
12793         [ALC262_BENQ_ED8] = {
12794                 .mixers = { alc262_base_mixer },
12795                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12796                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12797                 .dac_nids = alc262_dac_nids,
12798                 .hp_nid = 0x03,
12799                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12800                 .channel_mode = alc262_modes,
12801                 .input_mux = &alc262_capture_source,
12802         },
12803         [ALC262_SONY_ASSAMD] = {
12804                 .mixers = { alc262_sony_mixer },
12805                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12806                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12807                 .dac_nids = alc262_dac_nids,
12808                 .hp_nid = 0x02,
12809                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12810                 .channel_mode = alc262_modes,
12811                 .input_mux = &alc262_capture_source,
12812                 .unsol_event = alc262_hippo_unsol_event,
12813                 .setup = alc262_hippo_setup,
12814                 .init_hook = alc262_hippo_automute,
12815         },
12816         [ALC262_BENQ_T31] = {
12817                 .mixers = { alc262_benq_t31_mixer },
12818                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12819                                 alc_hp15_unsol_verbs },
12820                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12821                 .dac_nids = alc262_dac_nids,
12822                 .hp_nid = 0x03,
12823                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12824                 .channel_mode = alc262_modes,
12825                 .input_mux = &alc262_capture_source,
12826                 .unsol_event = alc262_hippo_unsol_event,
12827                 .setup = alc262_hippo_setup,
12828                 .init_hook = alc262_hippo_automute,
12829         },
12830         [ALC262_ULTRA] = {
12831                 .mixers = { alc262_ultra_mixer },
12832                 .cap_mixer = alc262_ultra_capture_mixer,
12833                 .init_verbs = { alc262_ultra_verbs },
12834                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12835                 .dac_nids = alc262_dac_nids,
12836                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12837                 .channel_mode = alc262_modes,
12838                 .input_mux = &alc262_ultra_capture_source,
12839                 .adc_nids = alc262_adc_nids, /* ADC0 */
12840                 .capsrc_nids = alc262_capsrc_nids,
12841                 .num_adc_nids = 1, /* single ADC */
12842                 .unsol_event = alc262_ultra_unsol_event,
12843                 .init_hook = alc262_ultra_automute,
12844         },
12845         [ALC262_LENOVO_3000] = {
12846                 .mixers = { alc262_lenovo_3000_mixer },
12847                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12848                                 alc262_lenovo_3000_unsol_verbs,
12849                                 alc262_lenovo_3000_init_verbs },
12850                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12851                 .dac_nids = alc262_dac_nids,
12852                 .hp_nid = 0x03,
12853                 .dig_out_nid = ALC262_DIGOUT_NID,
12854                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12855                 .channel_mode = alc262_modes,
12856                 .input_mux = &alc262_fujitsu_capture_source,
12857                 .unsol_event = alc262_lenovo_3000_unsol_event,
12858         },
12859         [ALC262_NEC] = {
12860                 .mixers = { alc262_nec_mixer },
12861                 .init_verbs = { alc262_nec_verbs },
12862                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12863                 .dac_nids = alc262_dac_nids,
12864                 .hp_nid = 0x03,
12865                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12866                 .channel_mode = alc262_modes,
12867                 .input_mux = &alc262_capture_source,
12868         },
12869         [ALC262_TOSHIBA_S06] = {
12870                 .mixers = { alc262_toshiba_s06_mixer },
12871                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12872                                                         alc262_eapd_verbs },
12873                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12874                 .capsrc_nids = alc262_dmic_capsrc_nids,
12875                 .dac_nids = alc262_dac_nids,
12876                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12877                 .num_adc_nids = 1, /* single ADC */
12878                 .dig_out_nid = ALC262_DIGOUT_NID,
12879                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12880                 .channel_mode = alc262_modes,
12881                 .unsol_event = alc_sku_unsol_event,
12882                 .setup = alc262_toshiba_s06_setup,
12883                 .init_hook = alc_inithook,
12884         },
12885         [ALC262_TOSHIBA_RX1] = {
12886                 .mixers = { alc262_toshiba_rx1_mixer },
12887                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_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 = alc262_hippo_unsol_event,
12895                 .setup = alc262_hippo_setup,
12896                 .init_hook = alc262_hippo_automute,
12897         },
12898         [ALC262_TYAN] = {
12899                 .mixers = { alc262_tyan_mixer },
12900                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12901                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12902                 .dac_nids = alc262_dac_nids,
12903                 .hp_nid = 0x02,
12904                 .dig_out_nid = ALC262_DIGOUT_NID,
12905                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12906                 .channel_mode = alc262_modes,
12907                 .input_mux = &alc262_capture_source,
12908                 .unsol_event = alc_automute_amp_unsol_event,
12909                 .setup = alc262_tyan_setup,
12910                 .init_hook = alc_automute_amp,
12911         },
12912 };
12913
12914 static int patch_alc262(struct hda_codec *codec)
12915 {
12916         struct alc_spec *spec;
12917         int board_config;
12918         int err;
12919
12920         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12921         if (spec == NULL)
12922                 return -ENOMEM;
12923
12924         codec->spec = spec;
12925 #if 0
12926         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12927          * under-run
12928          */
12929         {
12930         int tmp;
12931         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12932         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12933         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12934         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12935         }
12936 #endif
12937         alc_auto_parse_customize_define(codec);
12938
12939         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12940
12941         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12942                                                   alc262_models,
12943                                                   alc262_cfg_tbl);
12944
12945         if (board_config < 0) {
12946                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12947                        codec->chip_name);
12948                 board_config = ALC262_AUTO;
12949         }
12950
12951         if (board_config == ALC262_AUTO) {
12952                 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
12953                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
12954         }
12955
12956         if (board_config == ALC262_AUTO) {
12957                 /* automatic parse from the BIOS config */
12958                 err = alc262_parse_auto_config(codec);
12959                 if (err < 0) {
12960                         alc_free(codec);
12961                         return err;
12962                 } else if (!err) {
12963                         printk(KERN_INFO
12964                                "hda_codec: Cannot set up configuration "
12965                                "from BIOS.  Using base mode...\n");
12966                         board_config = ALC262_BASIC;
12967                 }
12968         }
12969
12970         if (!spec->no_analog && has_cdefine_beep(codec)) {
12971                 err = snd_hda_attach_beep_device(codec, 0x1);
12972                 if (err < 0) {
12973                         alc_free(codec);
12974                         return err;
12975                 }
12976         }
12977
12978         if (board_config != ALC262_AUTO)
12979                 setup_preset(codec, &alc262_presets[board_config]);
12980
12981         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12982         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12983
12984         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12985         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12986
12987         if (!spec->adc_nids && spec->input_mux) {
12988                 int i;
12989                 /* check whether the digital-mic has to be supported */
12990                 for (i = 0; i < spec->input_mux->num_items; i++) {
12991                         if (spec->input_mux->items[i].index >= 9)
12992                                 break;
12993                 }
12994                 if (i < spec->input_mux->num_items) {
12995                         /* use only ADC0 */
12996                         spec->adc_nids = alc262_dmic_adc_nids;
12997                         spec->num_adc_nids = 1;
12998                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12999                 } else {
13000                         /* all analog inputs */
13001                         /* check whether NID 0x07 is valid */
13002                         unsigned int wcap = get_wcaps(codec, 0x07);
13003
13004                         /* get type */
13005                         wcap = get_wcaps_type(wcap);
13006                         if (wcap != AC_WID_AUD_IN) {
13007                                 spec->adc_nids = alc262_adc_nids_alt;
13008                                 spec->num_adc_nids =
13009                                         ARRAY_SIZE(alc262_adc_nids_alt);
13010                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
13011                         } else {
13012                                 spec->adc_nids = alc262_adc_nids;
13013                                 spec->num_adc_nids =
13014                                         ARRAY_SIZE(alc262_adc_nids);
13015                                 spec->capsrc_nids = alc262_capsrc_nids;
13016                         }
13017                 }
13018         }
13019         if (!spec->cap_mixer && !spec->no_analog)
13020                 set_capture_mixer(codec);
13021         if (!spec->no_analog && has_cdefine_beep(codec))
13022                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13023
13024         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
13025
13026         spec->vmaster_nid = 0x0c;
13027
13028         codec->patch_ops = alc_patch_ops;
13029         if (board_config == ALC262_AUTO)
13030                 spec->init_hook = alc262_auto_init;
13031
13032         alc_init_jacks(codec);
13033 #ifdef CONFIG_SND_HDA_POWER_SAVE
13034         if (!spec->loopback.amplist)
13035                 spec->loopback.amplist = alc262_loopbacks;
13036 #endif
13037
13038         return 0;
13039 }
13040
13041 /*
13042  *  ALC268 channel source setting (2 channel)
13043  */
13044 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
13045 #define alc268_modes            alc260_modes
13046
13047 static hda_nid_t alc268_dac_nids[2] = {
13048         /* front, hp */
13049         0x02, 0x03
13050 };
13051
13052 static hda_nid_t alc268_adc_nids[2] = {
13053         /* ADC0-1 */
13054         0x08, 0x07
13055 };
13056
13057 static hda_nid_t alc268_adc_nids_alt[1] = {
13058         /* ADC0 */
13059         0x08
13060 };
13061
13062 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
13063
13064 static struct snd_kcontrol_new alc268_base_mixer[] = {
13065         /* output mixer control */
13066         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13067         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13068         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13069         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13070         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13071         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13072         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13073         { }
13074 };
13075
13076 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13077         /* output mixer control */
13078         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13079         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13080         ALC262_HIPPO_MASTER_SWITCH,
13081         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13082         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13083         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13084         { }
13085 };
13086
13087 /* bind Beep switches of both NID 0x0f and 0x10 */
13088 static struct hda_bind_ctls alc268_bind_beep_sw = {
13089         .ops = &snd_hda_bind_sw,
13090         .values = {
13091                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13092                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13093                 0
13094         },
13095 };
13096
13097 static struct snd_kcontrol_new alc268_beep_mixer[] = {
13098         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13099         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13100         { }
13101 };
13102
13103 static struct hda_verb alc268_eapd_verbs[] = {
13104         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13105         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13106         { }
13107 };
13108
13109 /* Toshiba specific */
13110 static struct hda_verb alc268_toshiba_verbs[] = {
13111         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13112         { } /* end */
13113 };
13114
13115 /* Acer specific */
13116 /* bind volumes of both NID 0x02 and 0x03 */
13117 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
13118         .ops = &snd_hda_bind_vol,
13119         .values = {
13120                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13121                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13122                 0
13123         },
13124 };
13125
13126 /* mute/unmute internal speaker according to the hp jack and mute state */
13127 static void alc268_acer_automute(struct hda_codec *codec, int force)
13128 {
13129         struct alc_spec *spec = codec->spec;
13130         unsigned int mute;
13131
13132         if (force || !spec->sense_updated) {
13133                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
13134                 spec->sense_updated = 1;
13135         }
13136         if (spec->jack_present)
13137                 mute = HDA_AMP_MUTE; /* mute internal speaker */
13138         else /* unmute internal speaker if necessary */
13139                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13140         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13141                                  HDA_AMP_MUTE, mute);
13142 }
13143
13144
13145 /* bind hp and internal speaker mute (with plug check) */
13146 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
13147                                      struct snd_ctl_elem_value *ucontrol)
13148 {
13149         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
13150         long *valp = ucontrol->value.integer.value;
13151         int change;
13152
13153         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
13154         if (change)
13155                 alc268_acer_automute(codec, 0);
13156         return change;
13157 }
13158
13159 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13160         /* output mixer control */
13161         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13162         {
13163                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13164                 .name = "Master Playback Switch",
13165                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13166                 .info = snd_hda_mixer_amp_switch_info,
13167                 .get = snd_hda_mixer_amp_switch_get,
13168                 .put = alc268_acer_master_sw_put,
13169                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13170         },
13171         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13172         { }
13173 };
13174
13175 static struct snd_kcontrol_new alc268_acer_mixer[] = {
13176         /* output mixer control */
13177         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13178         {
13179                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13180                 .name = "Master Playback Switch",
13181                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13182                 .info = snd_hda_mixer_amp_switch_info,
13183                 .get = snd_hda_mixer_amp_switch_get,
13184                 .put = alc268_acer_master_sw_put,
13185                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13186         },
13187         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13188         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13189         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13190         { }
13191 };
13192
13193 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13194         /* output mixer control */
13195         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13196         {
13197                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13198                 .name = "Master Playback Switch",
13199                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13200                 .info = snd_hda_mixer_amp_switch_info,
13201                 .get = snd_hda_mixer_amp_switch_get,
13202                 .put = alc268_acer_master_sw_put,
13203                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13204         },
13205         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13206         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13207         { }
13208 };
13209
13210 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13211         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13212         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13213         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13214         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13215         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13216         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13217         { }
13218 };
13219
13220 static struct hda_verb alc268_acer_verbs[] = {
13221         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13222         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13223         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13224         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13225         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13226         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13227         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13228         { }
13229 };
13230
13231 /* unsolicited event for HP jack sensing */
13232 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
13233 #define alc268_toshiba_setup            alc262_hippo_setup
13234 #define alc268_toshiba_automute         alc262_hippo_automute
13235
13236 static void alc268_acer_unsol_event(struct hda_codec *codec,
13237                                        unsigned int res)
13238 {
13239         if ((res >> 26) != ALC880_HP_EVENT)
13240                 return;
13241         alc268_acer_automute(codec, 1);
13242 }
13243
13244 static void alc268_acer_init_hook(struct hda_codec *codec)
13245 {
13246         alc268_acer_automute(codec, 1);
13247 }
13248
13249 /* toggle speaker-output according to the hp-jack state */
13250 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13251 {
13252         unsigned int present;
13253         unsigned char bits;
13254
13255         present = snd_hda_jack_detect(codec, 0x15);
13256         bits = present ? HDA_AMP_MUTE : 0;
13257         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13258                                  HDA_AMP_MUTE, bits);
13259         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13260                                  HDA_AMP_MUTE, bits);
13261 }
13262
13263 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13264                                     unsigned int res)
13265 {
13266         switch (res >> 26) {
13267         case ALC880_HP_EVENT:
13268                 alc268_aspire_one_speaker_automute(codec);
13269                 break;
13270         case ALC880_MIC_EVENT:
13271                 alc_mic_automute(codec);
13272                 break;
13273         }
13274 }
13275
13276 static void alc268_acer_lc_setup(struct hda_codec *codec)
13277 {
13278         struct alc_spec *spec = codec->spec;
13279         spec->ext_mic.pin = 0x18;
13280         spec->ext_mic.mux_idx = 0;
13281         spec->int_mic.pin = 0x12;
13282         spec->int_mic.mux_idx = 6;
13283         spec->auto_mic = 1;
13284 }
13285
13286 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13287 {
13288         alc268_aspire_one_speaker_automute(codec);
13289         alc_mic_automute(codec);
13290 }
13291
13292 static struct snd_kcontrol_new alc268_dell_mixer[] = {
13293         /* output mixer control */
13294         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13295         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13296         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13297         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13298         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13299         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13300         { }
13301 };
13302
13303 static struct hda_verb alc268_dell_verbs[] = {
13304         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13305         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13306         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13307         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13308         { }
13309 };
13310
13311 /* mute/unmute internal speaker according to the hp jack and mute state */
13312 static void alc268_dell_setup(struct hda_codec *codec)
13313 {
13314         struct alc_spec *spec = codec->spec;
13315
13316         spec->autocfg.hp_pins[0] = 0x15;
13317         spec->autocfg.speaker_pins[0] = 0x14;
13318         spec->ext_mic.pin = 0x18;
13319         spec->ext_mic.mux_idx = 0;
13320         spec->int_mic.pin = 0x19;
13321         spec->int_mic.mux_idx = 1;
13322         spec->auto_mic = 1;
13323 }
13324
13325 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13326         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13327         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13328         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13329         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13330         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13331         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13332         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13333         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13334         { }
13335 };
13336
13337 static struct hda_verb alc267_quanta_il1_verbs[] = {
13338         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13339         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13340         { }
13341 };
13342
13343 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13344 {
13345         struct alc_spec *spec = codec->spec;
13346         spec->autocfg.hp_pins[0] = 0x15;
13347         spec->autocfg.speaker_pins[0] = 0x14;
13348         spec->ext_mic.pin = 0x18;
13349         spec->ext_mic.mux_idx = 0;
13350         spec->int_mic.pin = 0x19;
13351         spec->int_mic.mux_idx = 1;
13352         spec->auto_mic = 1;
13353 }
13354
13355 /*
13356  * generic initialization of ADC, input mixers and output mixers
13357  */
13358 static struct hda_verb alc268_base_init_verbs[] = {
13359         /* Unmute DAC0-1 and set vol = 0 */
13360         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13361         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13362
13363         /*
13364          * Set up output mixers (0x0c - 0x0e)
13365          */
13366         /* set vol=0 to output mixers */
13367         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13368         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13369
13370         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13371         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13372
13373         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13374         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13375         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13376         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13377         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13378         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13379         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13380         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13381
13382         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13383         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13384         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13385         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13386         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13387
13388         /* set PCBEEP vol = 0, mute connections */
13389         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13390         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13391         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13392
13393         /* Unmute Selector 23h,24h and set the default input to mic-in */
13394
13395         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13396         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13397         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13398         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13399
13400         { }
13401 };
13402
13403 /*
13404  * generic initialization of ADC, input mixers and output mixers
13405  */
13406 static struct hda_verb alc268_volume_init_verbs[] = {
13407         /* set output DAC */
13408         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13409         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13410
13411         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13412         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13413         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13414         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13415         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13416
13417         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13418         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13419         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13420
13421         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13422         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13423
13424         /* set PCBEEP vol = 0, mute connections */
13425         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13426         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13427         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13428
13429         { }
13430 };
13431
13432 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13433         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13434         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13435         { } /* end */
13436 };
13437
13438 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13439         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13440         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13441         _DEFINE_CAPSRC(1),
13442         { } /* end */
13443 };
13444
13445 static struct snd_kcontrol_new alc268_capture_mixer[] = {
13446         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13447         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13448         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13449         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13450         _DEFINE_CAPSRC(2),
13451         { } /* end */
13452 };
13453
13454 static struct hda_input_mux alc268_capture_source = {
13455         .num_items = 4,
13456         .items = {
13457                 { "Mic", 0x0 },
13458                 { "Front Mic", 0x1 },
13459                 { "Line", 0x2 },
13460                 { "CD", 0x3 },
13461         },
13462 };
13463
13464 static struct hda_input_mux alc268_acer_capture_source = {
13465         .num_items = 3,
13466         .items = {
13467                 { "Mic", 0x0 },
13468                 { "Internal Mic", 0x1 },
13469                 { "Line", 0x2 },
13470         },
13471 };
13472
13473 static struct hda_input_mux alc268_acer_dmic_capture_source = {
13474         .num_items = 3,
13475         .items = {
13476                 { "Mic", 0x0 },
13477                 { "Internal Mic", 0x6 },
13478                 { "Line", 0x2 },
13479         },
13480 };
13481
13482 #ifdef CONFIG_SND_DEBUG
13483 static struct snd_kcontrol_new alc268_test_mixer[] = {
13484         /* Volume widgets */
13485         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13486         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13487         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13488         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13489         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13490         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13491         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13492         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13493         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13494         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13495         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13496         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13497         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13498         /* The below appears problematic on some hardwares */
13499         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13500         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13501         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13502         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13503         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13504
13505         /* Modes for retasking pin widgets */
13506         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13507         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13508         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13509         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13510
13511         /* Controls for GPIO pins, assuming they are configured as outputs */
13512         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13513         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13514         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13515         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13516
13517         /* Switches to allow the digital SPDIF output pin to be enabled.
13518          * The ALC268 does not have an SPDIF input.
13519          */
13520         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13521
13522         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13523          * this output to turn on an external amplifier.
13524          */
13525         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13526         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13527
13528         { } /* end */
13529 };
13530 #endif
13531
13532 /* create input playback/capture controls for the given pin */
13533 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13534                                     const char *ctlname, int idx)
13535 {
13536         hda_nid_t dac;
13537         int err;
13538
13539         switch (nid) {
13540         case 0x14:
13541         case 0x16:
13542                 dac = 0x02;
13543                 break;
13544         case 0x15:
13545         case 0x1a: /* ALC259/269 only */
13546         case 0x1b: /* ALC259/269 only */
13547         case 0x21: /* ALC269vb has this pin, too */
13548                 dac = 0x03;
13549                 break;
13550         default:
13551                 snd_printd(KERN_WARNING "hda_codec: "
13552                            "ignoring pin 0x%x as unknown\n", nid);
13553                 return 0;
13554         }
13555         if (spec->multiout.dac_nids[0] != dac &&
13556             spec->multiout.dac_nids[1] != dac) {
13557                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13558                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13559                                                       HDA_OUTPUT));
13560                 if (err < 0)
13561                         return err;
13562                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13563         }
13564
13565         if (nid != 0x16)
13566                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13567                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13568         else /* mono */
13569                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13570                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13571         if (err < 0)
13572                 return err;
13573         return 0;
13574 }
13575
13576 /* add playback controls from the parsed DAC table */
13577 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13578                                              const struct auto_pin_cfg *cfg)
13579 {
13580         hda_nid_t nid;
13581         int err;
13582
13583         spec->multiout.dac_nids = spec->private_dac_nids;
13584
13585         nid = cfg->line_out_pins[0];
13586         if (nid) {
13587                 const char *name;
13588                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13589                         name = "Speaker";
13590                 else
13591                         name = "Front";
13592                 err = alc268_new_analog_output(spec, nid, name, 0);
13593                 if (err < 0)
13594                         return err;
13595         }
13596
13597         nid = cfg->speaker_pins[0];
13598         if (nid == 0x1d) {
13599                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13600                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13601                 if (err < 0)
13602                         return err;
13603         } else if (nid) {
13604                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13605                 if (err < 0)
13606                         return err;
13607         }
13608         nid = cfg->hp_pins[0];
13609         if (nid) {
13610                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13611                 if (err < 0)
13612                         return err;
13613         }
13614
13615         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13616         if (nid == 0x16) {
13617                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13618                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13619                 if (err < 0)
13620                         return err;
13621         }
13622         return 0;
13623 }
13624
13625 /* create playback/capture controls for input pins */
13626 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13627                                                 const struct auto_pin_cfg *cfg)
13628 {
13629         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13630 }
13631
13632 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13633                                               hda_nid_t nid, int pin_type)
13634 {
13635         int idx;
13636
13637         alc_set_pin_output(codec, nid, pin_type);
13638         if (nid == 0x14 || nid == 0x16)
13639                 idx = 0;
13640         else
13641                 idx = 1;
13642         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13643 }
13644
13645 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13646 {
13647         struct alc_spec *spec = codec->spec;
13648         int i;
13649
13650         for (i = 0; i < spec->autocfg.line_outs; i++) {
13651                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13652                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13653                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13654         }
13655 }
13656
13657 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13658 {
13659         struct alc_spec *spec = codec->spec;
13660         hda_nid_t pin;
13661         int i;
13662
13663         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13664                 pin = spec->autocfg.hp_pins[i];
13665                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13666         }
13667         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13668                 pin = spec->autocfg.speaker_pins[i];
13669                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13670         }
13671         if (spec->autocfg.mono_out_pin)
13672                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13673                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13674 }
13675
13676 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13677 {
13678         struct alc_spec *spec = codec->spec;
13679         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13680         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13681         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13682         unsigned int    dac_vol1, dac_vol2;
13683
13684         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13685                 snd_hda_codec_write(codec, speaker_nid, 0,
13686                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13687                 /* mute mixer inputs from 0x1d */
13688                 snd_hda_codec_write(codec, 0x0f, 0,
13689                                     AC_VERB_SET_AMP_GAIN_MUTE,
13690                                     AMP_IN_UNMUTE(1));
13691                 snd_hda_codec_write(codec, 0x10, 0,
13692                                     AC_VERB_SET_AMP_GAIN_MUTE,
13693                                     AMP_IN_UNMUTE(1));
13694         } else {
13695                 /* unmute mixer inputs from 0x1d */
13696                 snd_hda_codec_write(codec, 0x0f, 0,
13697                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13698                 snd_hda_codec_write(codec, 0x10, 0,
13699                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13700         }
13701
13702         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13703         if (line_nid == 0x14)
13704                 dac_vol2 = AMP_OUT_ZERO;
13705         else if (line_nid == 0x15)
13706                 dac_vol1 = AMP_OUT_ZERO;
13707         if (hp_nid == 0x14)
13708                 dac_vol2 = AMP_OUT_ZERO;
13709         else if (hp_nid == 0x15)
13710                 dac_vol1 = AMP_OUT_ZERO;
13711         if (line_nid != 0x16 || hp_nid != 0x16 ||
13712             spec->autocfg.line_out_pins[1] != 0x16 ||
13713             spec->autocfg.line_out_pins[2] != 0x16)
13714                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13715
13716         snd_hda_codec_write(codec, 0x02, 0,
13717                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13718         snd_hda_codec_write(codec, 0x03, 0,
13719                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13720 }
13721
13722 /* pcm configuration: identical with ALC880 */
13723 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13724 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13725 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13726 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13727
13728 /*
13729  * BIOS auto configuration
13730  */
13731 static int alc268_parse_auto_config(struct hda_codec *codec)
13732 {
13733         struct alc_spec *spec = codec->spec;
13734         int err;
13735         static hda_nid_t alc268_ignore[] = { 0 };
13736
13737         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13738                                            alc268_ignore);
13739         if (err < 0)
13740                 return err;
13741         if (!spec->autocfg.line_outs) {
13742                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13743                         spec->multiout.max_channels = 2;
13744                         spec->no_analog = 1;
13745                         goto dig_only;
13746                 }
13747                 return 0; /* can't find valid BIOS pin config */
13748         }
13749         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13750         if (err < 0)
13751                 return err;
13752         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13753         if (err < 0)
13754                 return err;
13755
13756         spec->multiout.max_channels = 2;
13757
13758  dig_only:
13759         /* digital only support output */
13760         alc_auto_parse_digital(codec);
13761         if (spec->kctls.list)
13762                 add_mixer(spec, spec->kctls.list);
13763
13764         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13765                 add_mixer(spec, alc268_beep_mixer);
13766
13767         add_verb(spec, alc268_volume_init_verbs);
13768         spec->num_mux_defs = 2;
13769         spec->input_mux = &spec->private_imux[0];
13770
13771         err = alc_auto_add_mic_boost(codec);
13772         if (err < 0)
13773                 return err;
13774
13775         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13776
13777         return 1;
13778 }
13779
13780 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13781
13782 /* init callback for auto-configuration model -- overriding the default init */
13783 static void alc268_auto_init(struct hda_codec *codec)
13784 {
13785         struct alc_spec *spec = codec->spec;
13786         alc268_auto_init_multi_out(codec);
13787         alc268_auto_init_hp_out(codec);
13788         alc268_auto_init_mono_speaker_out(codec);
13789         alc268_auto_init_analog_input(codec);
13790         alc_auto_init_digital(codec);
13791         if (spec->unsol_event)
13792                 alc_inithook(codec);
13793 }
13794
13795 /*
13796  * configuration and preset
13797  */
13798 static const char * const alc268_models[ALC268_MODEL_LAST] = {
13799         [ALC267_QUANTA_IL1]     = "quanta-il1",
13800         [ALC268_3ST]            = "3stack",
13801         [ALC268_TOSHIBA]        = "toshiba",
13802         [ALC268_ACER]           = "acer",
13803         [ALC268_ACER_DMIC]      = "acer-dmic",
13804         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13805         [ALC268_DELL]           = "dell",
13806         [ALC268_ZEPTO]          = "zepto",
13807 #ifdef CONFIG_SND_DEBUG
13808         [ALC268_TEST]           = "test",
13809 #endif
13810         [ALC268_AUTO]           = "auto",
13811 };
13812
13813 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13814         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13815         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13816         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13817         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13818         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13819         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13820                                                 ALC268_ACER_ASPIRE_ONE),
13821         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13822         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13823                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13824         /* almost compatible with toshiba but with optional digital outs;
13825          * auto-probing seems working fine
13826          */
13827         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13828                            ALC268_AUTO),
13829         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13830         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13831         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13832         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13833         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13834         {}
13835 };
13836
13837 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13838 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13839         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13840         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13841         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13842                            ALC268_TOSHIBA),
13843         {}
13844 };
13845
13846 static struct alc_config_preset alc268_presets[] = {
13847         [ALC267_QUANTA_IL1] = {
13848                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13849                             alc268_capture_nosrc_mixer },
13850                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13851                                 alc267_quanta_il1_verbs },
13852                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13853                 .dac_nids = alc268_dac_nids,
13854                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13855                 .adc_nids = alc268_adc_nids_alt,
13856                 .hp_nid = 0x03,
13857                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13858                 .channel_mode = alc268_modes,
13859                 .unsol_event = alc_sku_unsol_event,
13860                 .setup = alc267_quanta_il1_setup,
13861                 .init_hook = alc_inithook,
13862         },
13863         [ALC268_3ST] = {
13864                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13865                             alc268_beep_mixer },
13866                 .init_verbs = { alc268_base_init_verbs },
13867                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13868                 .dac_nids = alc268_dac_nids,
13869                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13870                 .adc_nids = alc268_adc_nids_alt,
13871                 .capsrc_nids = alc268_capsrc_nids,
13872                 .hp_nid = 0x03,
13873                 .dig_out_nid = ALC268_DIGOUT_NID,
13874                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13875                 .channel_mode = alc268_modes,
13876                 .input_mux = &alc268_capture_source,
13877         },
13878         [ALC268_TOSHIBA] = {
13879                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13880                             alc268_beep_mixer },
13881                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13882                                 alc268_toshiba_verbs },
13883                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13884                 .dac_nids = alc268_dac_nids,
13885                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13886                 .adc_nids = alc268_adc_nids_alt,
13887                 .capsrc_nids = alc268_capsrc_nids,
13888                 .hp_nid = 0x03,
13889                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13890                 .channel_mode = alc268_modes,
13891                 .input_mux = &alc268_capture_source,
13892                 .unsol_event = alc268_toshiba_unsol_event,
13893                 .setup = alc268_toshiba_setup,
13894                 .init_hook = alc268_toshiba_automute,
13895         },
13896         [ALC268_ACER] = {
13897                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13898                             alc268_beep_mixer },
13899                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13900                                 alc268_acer_verbs },
13901                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13902                 .dac_nids = alc268_dac_nids,
13903                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13904                 .adc_nids = alc268_adc_nids_alt,
13905                 .capsrc_nids = alc268_capsrc_nids,
13906                 .hp_nid = 0x02,
13907                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13908                 .channel_mode = alc268_modes,
13909                 .input_mux = &alc268_acer_capture_source,
13910                 .unsol_event = alc268_acer_unsol_event,
13911                 .init_hook = alc268_acer_init_hook,
13912         },
13913         [ALC268_ACER_DMIC] = {
13914                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13915                             alc268_beep_mixer },
13916                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13917                                 alc268_acer_verbs },
13918                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13919                 .dac_nids = alc268_dac_nids,
13920                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13921                 .adc_nids = alc268_adc_nids_alt,
13922                 .capsrc_nids = alc268_capsrc_nids,
13923                 .hp_nid = 0x02,
13924                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13925                 .channel_mode = alc268_modes,
13926                 .input_mux = &alc268_acer_dmic_capture_source,
13927                 .unsol_event = alc268_acer_unsol_event,
13928                 .init_hook = alc268_acer_init_hook,
13929         },
13930         [ALC268_ACER_ASPIRE_ONE] = {
13931                 .mixers = { alc268_acer_aspire_one_mixer,
13932                             alc268_beep_mixer,
13933                             alc268_capture_nosrc_mixer },
13934                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13935                                 alc268_acer_aspire_one_verbs },
13936                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13937                 .dac_nids = alc268_dac_nids,
13938                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13939                 .adc_nids = alc268_adc_nids_alt,
13940                 .capsrc_nids = alc268_capsrc_nids,
13941                 .hp_nid = 0x03,
13942                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13943                 .channel_mode = alc268_modes,
13944                 .unsol_event = alc268_acer_lc_unsol_event,
13945                 .setup = alc268_acer_lc_setup,
13946                 .init_hook = alc268_acer_lc_init_hook,
13947         },
13948         [ALC268_DELL] = {
13949                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13950                             alc268_capture_nosrc_mixer },
13951                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13952                                 alc268_dell_verbs },
13953                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13954                 .dac_nids = alc268_dac_nids,
13955                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13956                 .adc_nids = alc268_adc_nids_alt,
13957                 .capsrc_nids = alc268_capsrc_nids,
13958                 .hp_nid = 0x02,
13959                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13960                 .channel_mode = alc268_modes,
13961                 .unsol_event = alc_sku_unsol_event,
13962                 .setup = alc268_dell_setup,
13963                 .init_hook = alc_inithook,
13964         },
13965         [ALC268_ZEPTO] = {
13966                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13967                             alc268_beep_mixer },
13968                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13969                                 alc268_toshiba_verbs },
13970                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13971                 .dac_nids = alc268_dac_nids,
13972                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13973                 .adc_nids = alc268_adc_nids_alt,
13974                 .capsrc_nids = alc268_capsrc_nids,
13975                 .hp_nid = 0x03,
13976                 .dig_out_nid = ALC268_DIGOUT_NID,
13977                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13978                 .channel_mode = alc268_modes,
13979                 .input_mux = &alc268_capture_source,
13980                 .setup = alc268_toshiba_setup,
13981                 .init_hook = alc268_toshiba_automute,
13982         },
13983 #ifdef CONFIG_SND_DEBUG
13984         [ALC268_TEST] = {
13985                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13986                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13987                                 alc268_volume_init_verbs },
13988                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13989                 .dac_nids = alc268_dac_nids,
13990                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13991                 .adc_nids = alc268_adc_nids_alt,
13992                 .capsrc_nids = alc268_capsrc_nids,
13993                 .hp_nid = 0x03,
13994                 .dig_out_nid = ALC268_DIGOUT_NID,
13995                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13996                 .channel_mode = alc268_modes,
13997                 .input_mux = &alc268_capture_source,
13998         },
13999 #endif
14000 };
14001
14002 static int patch_alc268(struct hda_codec *codec)
14003 {
14004         struct alc_spec *spec;
14005         int board_config;
14006         int i, has_beep, err;
14007
14008         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14009         if (spec == NULL)
14010                 return -ENOMEM;
14011
14012         codec->spec = spec;
14013
14014         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
14015                                                   alc268_models,
14016                                                   alc268_cfg_tbl);
14017
14018         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
14019                 board_config = snd_hda_check_board_codec_sid_config(codec,
14020                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
14021
14022         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
14023                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14024                        codec->chip_name);
14025                 board_config = ALC268_AUTO;
14026         }
14027
14028         if (board_config == ALC268_AUTO) {
14029                 /* automatic parse from the BIOS config */
14030                 err = alc268_parse_auto_config(codec);
14031                 if (err < 0) {
14032                         alc_free(codec);
14033                         return err;
14034                 } else if (!err) {
14035                         printk(KERN_INFO
14036                                "hda_codec: Cannot set up configuration "
14037                                "from BIOS.  Using base mode...\n");
14038                         board_config = ALC268_3ST;
14039                 }
14040         }
14041
14042         if (board_config != ALC268_AUTO)
14043                 setup_preset(codec, &alc268_presets[board_config]);
14044
14045         spec->stream_analog_playback = &alc268_pcm_analog_playback;
14046         spec->stream_analog_capture = &alc268_pcm_analog_capture;
14047         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
14048
14049         spec->stream_digital_playback = &alc268_pcm_digital_playback;
14050
14051         has_beep = 0;
14052         for (i = 0; i < spec->num_mixers; i++) {
14053                 if (spec->mixers[i] == alc268_beep_mixer) {
14054                         has_beep = 1;
14055                         break;
14056                 }
14057         }
14058
14059         if (has_beep) {
14060                 err = snd_hda_attach_beep_device(codec, 0x1);
14061                 if (err < 0) {
14062                         alc_free(codec);
14063                         return err;
14064                 }
14065                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
14066                         /* override the amp caps for beep generator */
14067                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
14068                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
14069                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14070                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14071                                           (0 << AC_AMPCAP_MUTE_SHIFT));
14072         }
14073
14074         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14075                 /* check whether NID 0x07 is valid */
14076                 unsigned int wcap = get_wcaps(codec, 0x07);
14077                 int i;
14078
14079                 spec->capsrc_nids = alc268_capsrc_nids;
14080                 /* get type */
14081                 wcap = get_wcaps_type(wcap);
14082                 if (spec->auto_mic ||
14083                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14084                         spec->adc_nids = alc268_adc_nids_alt;
14085                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14086                         if (spec->auto_mic)
14087                                 fixup_automic_adc(codec);
14088                         if (spec->auto_mic || spec->input_mux->num_items == 1)
14089                                 add_mixer(spec, alc268_capture_nosrc_mixer);
14090                         else
14091                                 add_mixer(spec, alc268_capture_alt_mixer);
14092                 } else {
14093                         spec->adc_nids = alc268_adc_nids;
14094                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14095                         add_mixer(spec, alc268_capture_mixer);
14096                 }
14097                 /* set default input source */
14098                 for (i = 0; i < spec->num_adc_nids; i++)
14099                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
14100                                 0, AC_VERB_SET_CONNECT_SEL,
14101                                 i < spec->num_mux_defs ?
14102                                 spec->input_mux[i].items[0].index :
14103                                 spec->input_mux->items[0].index);
14104         }
14105
14106         spec->vmaster_nid = 0x02;
14107
14108         codec->patch_ops = alc_patch_ops;
14109         if (board_config == ALC268_AUTO)
14110                 spec->init_hook = alc268_auto_init;
14111
14112         alc_init_jacks(codec);
14113
14114         return 0;
14115 }
14116
14117 /*
14118  *  ALC269 channel source setting (2 channel)
14119  */
14120 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
14121
14122 #define alc269_dac_nids         alc260_dac_nids
14123
14124 static hda_nid_t alc269_adc_nids[1] = {
14125         /* ADC1 */
14126         0x08,
14127 };
14128
14129 static hda_nid_t alc269_capsrc_nids[1] = {
14130         0x23,
14131 };
14132
14133 static hda_nid_t alc269vb_adc_nids[1] = {
14134         /* ADC1 */
14135         0x09,
14136 };
14137
14138 static hda_nid_t alc269vb_capsrc_nids[1] = {
14139         0x22,
14140 };
14141
14142 static hda_nid_t alc269_adc_candidates[] = {
14143         0x08, 0x09, 0x07,
14144 };
14145
14146 #define alc269_modes            alc260_modes
14147 #define alc269_capture_source   alc880_lg_lw_capture_source
14148
14149 static struct snd_kcontrol_new alc269_base_mixer[] = {
14150         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14151         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14152         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14153         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14154         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14155         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14156         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14157         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14158         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14159         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
14160         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14161         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14162         { } /* end */
14163 };
14164
14165 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14166         /* output mixer control */
14167         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14168         {
14169                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14170                 .name = "Master Playback Switch",
14171                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14172                 .info = snd_hda_mixer_amp_switch_info,
14173                 .get = snd_hda_mixer_amp_switch_get,
14174                 .put = alc268_acer_master_sw_put,
14175                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14176         },
14177         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14178         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14179         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14180         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14181         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14182         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14183         { }
14184 };
14185
14186 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14187         /* output mixer control */
14188         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14189         {
14190                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14191                 .name = "Master Playback Switch",
14192                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14193                 .info = snd_hda_mixer_amp_switch_info,
14194                 .get = snd_hda_mixer_amp_switch_get,
14195                 .put = alc268_acer_master_sw_put,
14196                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14197         },
14198         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14199         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14200         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14201         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14202         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14203         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14204         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14205         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14206         HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
14207         { }
14208 };
14209
14210 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14211         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14212         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14213         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14214         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14215         { } /* end */
14216 };
14217
14218 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14219         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14220         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14221         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14222         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14223         { } /* end */
14224 };
14225
14226 static struct snd_kcontrol_new alc269_asus_mixer[] = {
14227         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14228         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14229         { } /* end */
14230 };
14231
14232 /* capture mixer elements */
14233 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14234         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14235         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14236         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14237         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14238         { } /* end */
14239 };
14240
14241 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14242         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14243         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14244         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14245         { } /* end */
14246 };
14247
14248 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14249         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14250         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14251         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14252         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14253         { } /* end */
14254 };
14255
14256 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14257         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14258         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14259         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14260         { } /* end */
14261 };
14262
14263 /* FSC amilo */
14264 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14265
14266 static struct hda_verb alc269_quanta_fl1_verbs[] = {
14267         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14268         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14269         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14270         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14271         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14272         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14273         { }
14274 };
14275
14276 static struct hda_verb alc269_lifebook_verbs[] = {
14277         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14278         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14279         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14280         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14281         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14282         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14283         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14284         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14285         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14286         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14287         { }
14288 };
14289
14290 /* toggle speaker-output according to the hp-jack state */
14291 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14292 {
14293         unsigned int present;
14294         unsigned char bits;
14295
14296         present = snd_hda_jack_detect(codec, 0x15);
14297         bits = present ? HDA_AMP_MUTE : 0;
14298         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14299                                  HDA_AMP_MUTE, bits);
14300         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14301                                  HDA_AMP_MUTE, bits);
14302
14303         snd_hda_codec_write(codec, 0x20, 0,
14304                         AC_VERB_SET_COEF_INDEX, 0x0c);
14305         snd_hda_codec_write(codec, 0x20, 0,
14306                         AC_VERB_SET_PROC_COEF, 0x680);
14307
14308         snd_hda_codec_write(codec, 0x20, 0,
14309                         AC_VERB_SET_COEF_INDEX, 0x0c);
14310         snd_hda_codec_write(codec, 0x20, 0,
14311                         AC_VERB_SET_PROC_COEF, 0x480);
14312 }
14313
14314 /* toggle speaker-output according to the hp-jacks state */
14315 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14316 {
14317         unsigned int present;
14318         unsigned char bits;
14319
14320         /* Check laptop headphone socket */
14321         present = snd_hda_jack_detect(codec, 0x15);
14322
14323         /* Check port replicator headphone socket */
14324         present |= snd_hda_jack_detect(codec, 0x1a);
14325
14326         bits = present ? HDA_AMP_MUTE : 0;
14327         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14328                                  HDA_AMP_MUTE, bits);
14329         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14330                                  HDA_AMP_MUTE, bits);
14331
14332         snd_hda_codec_write(codec, 0x20, 0,
14333                         AC_VERB_SET_COEF_INDEX, 0x0c);
14334         snd_hda_codec_write(codec, 0x20, 0,
14335                         AC_VERB_SET_PROC_COEF, 0x680);
14336
14337         snd_hda_codec_write(codec, 0x20, 0,
14338                         AC_VERB_SET_COEF_INDEX, 0x0c);
14339         snd_hda_codec_write(codec, 0x20, 0,
14340                         AC_VERB_SET_PROC_COEF, 0x480);
14341 }
14342
14343 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14344 {
14345         unsigned int present_laptop;
14346         unsigned int present_dock;
14347
14348         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14349         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14350
14351         /* Laptop mic port overrides dock mic port, design decision */
14352         if (present_dock)
14353                 snd_hda_codec_write(codec, 0x23, 0,
14354                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14355         if (present_laptop)
14356                 snd_hda_codec_write(codec, 0x23, 0,
14357                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14358         if (!present_dock && !present_laptop)
14359                 snd_hda_codec_write(codec, 0x23, 0,
14360                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14361 }
14362
14363 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14364                                     unsigned int res)
14365 {
14366         switch (res >> 26) {
14367         case ALC880_HP_EVENT:
14368                 alc269_quanta_fl1_speaker_automute(codec);
14369                 break;
14370         case ALC880_MIC_EVENT:
14371                 alc_mic_automute(codec);
14372                 break;
14373         }
14374 }
14375
14376 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14377                                         unsigned int res)
14378 {
14379         if ((res >> 26) == ALC880_HP_EVENT)
14380                 alc269_lifebook_speaker_automute(codec);
14381         if ((res >> 26) == ALC880_MIC_EVENT)
14382                 alc269_lifebook_mic_autoswitch(codec);
14383 }
14384
14385 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14386 {
14387         struct alc_spec *spec = codec->spec;
14388         spec->autocfg.hp_pins[0] = 0x15;
14389         spec->autocfg.speaker_pins[0] = 0x14;
14390         spec->ext_mic.pin = 0x18;
14391         spec->ext_mic.mux_idx = 0;
14392         spec->int_mic.pin = 0x19;
14393         spec->int_mic.mux_idx = 1;
14394         spec->auto_mic = 1;
14395 }
14396
14397 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14398 {
14399         alc269_quanta_fl1_speaker_automute(codec);
14400         alc_mic_automute(codec);
14401 }
14402
14403 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14404 {
14405         alc269_lifebook_speaker_automute(codec);
14406         alc269_lifebook_mic_autoswitch(codec);
14407 }
14408
14409 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14410         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14411         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14412         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14413         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14414         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14415         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14416         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14417         {}
14418 };
14419
14420 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14421         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14422         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14423         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14424         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14425         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14426         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14427         {}
14428 };
14429
14430 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14431         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14432         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14433         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14434         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14435         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14436         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14437         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14438         {}
14439 };
14440
14441 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14442         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14443         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14444         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14445         {0x09, 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         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14449         {}
14450 };
14451
14452 static struct hda_verb alc271_acer_dmic_verbs[] = {
14453         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14454         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14455         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14456         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14457         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14458         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14459         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14460         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14461         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14462         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14463         { }
14464 };
14465
14466 /* toggle speaker-output according to the hp-jack state */
14467 static void alc269_speaker_automute(struct hda_codec *codec)
14468 {
14469         struct alc_spec *spec = codec->spec;
14470         unsigned int nid = spec->autocfg.hp_pins[0];
14471         unsigned int present;
14472         unsigned char bits;
14473
14474         present = snd_hda_jack_detect(codec, nid);
14475         bits = present ? HDA_AMP_MUTE : 0;
14476         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14477                                  HDA_AMP_MUTE, bits);
14478         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14479                                  HDA_AMP_MUTE, bits);
14480         alc_report_jack(codec, nid);
14481 }
14482
14483 /* unsolicited event for HP jack sensing */
14484 static void alc269_laptop_unsol_event(struct hda_codec *codec,
14485                                      unsigned int res)
14486 {
14487         switch (res >> 26) {
14488         case ALC880_HP_EVENT:
14489                 alc269_speaker_automute(codec);
14490                 break;
14491         case ALC880_MIC_EVENT:
14492                 alc_mic_automute(codec);
14493                 break;
14494         }
14495 }
14496
14497 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14498 {
14499         struct alc_spec *spec = codec->spec;
14500         spec->autocfg.hp_pins[0] = 0x15;
14501         spec->autocfg.speaker_pins[0] = 0x14;
14502         spec->ext_mic.pin = 0x18;
14503         spec->ext_mic.mux_idx = 0;
14504         spec->int_mic.pin = 0x19;
14505         spec->int_mic.mux_idx = 1;
14506         spec->auto_mic = 1;
14507 }
14508
14509 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14510 {
14511         struct alc_spec *spec = codec->spec;
14512         spec->autocfg.hp_pins[0] = 0x15;
14513         spec->autocfg.speaker_pins[0] = 0x14;
14514         spec->ext_mic.pin = 0x18;
14515         spec->ext_mic.mux_idx = 0;
14516         spec->int_mic.pin = 0x12;
14517         spec->int_mic.mux_idx = 5;
14518         spec->auto_mic = 1;
14519 }
14520
14521 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14522 {
14523         struct alc_spec *spec = codec->spec;
14524         spec->autocfg.hp_pins[0] = 0x21;
14525         spec->autocfg.speaker_pins[0] = 0x14;
14526         spec->ext_mic.pin = 0x18;
14527         spec->ext_mic.mux_idx = 0;
14528         spec->int_mic.pin = 0x19;
14529         spec->int_mic.mux_idx = 1;
14530         spec->auto_mic = 1;
14531 }
14532
14533 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14534 {
14535         struct alc_spec *spec = codec->spec;
14536         spec->autocfg.hp_pins[0] = 0x21;
14537         spec->autocfg.speaker_pins[0] = 0x14;
14538         spec->ext_mic.pin = 0x18;
14539         spec->ext_mic.mux_idx = 0;
14540         spec->int_mic.pin = 0x12;
14541         spec->int_mic.mux_idx = 6;
14542         spec->auto_mic = 1;
14543 }
14544
14545 static void alc269_laptop_inithook(struct hda_codec *codec)
14546 {
14547         alc269_speaker_automute(codec);
14548         alc_mic_automute(codec);
14549 }
14550
14551 /*
14552  * generic initialization of ADC, input mixers and output mixers
14553  */
14554 static struct hda_verb alc269_init_verbs[] = {
14555         /*
14556          * Unmute ADC0 and set the default input to mic-in
14557          */
14558         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14559
14560         /*
14561          * Set up output mixers (0x02 - 0x03)
14562          */
14563         /* set vol=0 to output mixers */
14564         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14565         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14566
14567         /* set up input amps for analog loopback */
14568         /* Amp Indices: DAC = 0, mixer = 1 */
14569         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14570         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14571         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14572         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14573         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14574         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14575
14576         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14577         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14578         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14579         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14580         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14581         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14582         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14583
14584         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14585         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14586
14587         /* FIXME: use Mux-type input source selection */
14588         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14589         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14590         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14591
14592         /* set EAPD */
14593         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14594         { }
14595 };
14596
14597 static struct hda_verb alc269vb_init_verbs[] = {
14598         /*
14599          * Unmute ADC0 and set the default input to mic-in
14600          */
14601         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14602
14603         /*
14604          * Set up output mixers (0x02 - 0x03)
14605          */
14606         /* set vol=0 to output mixers */
14607         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14608         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14609
14610         /* set up input amps for analog loopback */
14611         /* Amp Indices: DAC = 0, mixer = 1 */
14612         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14613         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14614         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14615         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14616         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14617         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14618
14619         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14620         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14621         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14622         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14623         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14624         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14625         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14626
14627         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14628         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14629
14630         /* FIXME: use Mux-type input source selection */
14631         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14632         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14633         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14634
14635         /* set EAPD */
14636         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14637         { }
14638 };
14639
14640 #define alc269_auto_create_multi_out_ctls \
14641         alc268_auto_create_multi_out_ctls
14642 #define alc269_auto_create_input_ctls \
14643         alc268_auto_create_input_ctls
14644
14645 #ifdef CONFIG_SND_HDA_POWER_SAVE
14646 #define alc269_loopbacks        alc880_loopbacks
14647 #endif
14648
14649 /* pcm configuration: identical with ALC880 */
14650 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14651 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14652 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14653 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14654
14655 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14656         .substreams = 1,
14657         .channels_min = 2,
14658         .channels_max = 8,
14659         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14660         /* NID is set in alc_build_pcms */
14661         .ops = {
14662                 .open = alc880_playback_pcm_open,
14663                 .prepare = alc880_playback_pcm_prepare,
14664                 .cleanup = alc880_playback_pcm_cleanup
14665         },
14666 };
14667
14668 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14669         .substreams = 1,
14670         .channels_min = 2,
14671         .channels_max = 2,
14672         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14673         /* NID is set in alc_build_pcms */
14674 };
14675
14676 #ifdef CONFIG_SND_HDA_POWER_SAVE
14677 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14678 {
14679         switch (codec->subsystem_id) {
14680         case 0x103c1586:
14681                 return 1;
14682         }
14683         return 0;
14684 }
14685
14686 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14687 {
14688         /* update mute-LED according to the speaker mute state */
14689         if (nid == 0x01 || nid == 0x14) {
14690                 int pinval;
14691                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14692                     HDA_AMP_MUTE)
14693                         pinval = 0x24;
14694                 else
14695                         pinval = 0x20;
14696                 /* mic2 vref pin is used for mute LED control */
14697                 snd_hda_codec_update_cache(codec, 0x19, 0,
14698                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14699                                            pinval);
14700         }
14701         return alc_check_power_status(codec, nid);
14702 }
14703 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14704
14705 static int alc275_setup_dual_adc(struct hda_codec *codec)
14706 {
14707         struct alc_spec *spec = codec->spec;
14708
14709         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14710                 return 0;
14711         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14712             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14713                 if (spec->ext_mic.pin <= 0x12) {
14714                         spec->private_adc_nids[0] = 0x08;
14715                         spec->private_adc_nids[1] = 0x11;
14716                         spec->private_capsrc_nids[0] = 0x23;
14717                         spec->private_capsrc_nids[1] = 0x22;
14718                 } else {
14719                         spec->private_adc_nids[0] = 0x11;
14720                         spec->private_adc_nids[1] = 0x08;
14721                         spec->private_capsrc_nids[0] = 0x22;
14722                         spec->private_capsrc_nids[1] = 0x23;
14723                 }
14724                 spec->adc_nids = spec->private_adc_nids;
14725                 spec->capsrc_nids = spec->private_capsrc_nids;
14726                 spec->num_adc_nids = 2;
14727                 spec->dual_adc_switch = 1;
14728                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14729                             spec->adc_nids[0], spec->adc_nids[1]);
14730                 return 1;
14731         }
14732         return 0;
14733 }
14734
14735 /* different alc269-variants */
14736 enum {
14737         ALC269_TYPE_NORMAL,
14738         ALC269_TYPE_ALC258,
14739         ALC269_TYPE_ALC259,
14740         ALC269_TYPE_ALC269VB,
14741         ALC269_TYPE_ALC270,
14742         ALC269_TYPE_ALC271X,
14743 };
14744
14745 /*
14746  * BIOS auto configuration
14747  */
14748 static int alc269_parse_auto_config(struct hda_codec *codec)
14749 {
14750         struct alc_spec *spec = codec->spec;
14751         int err;
14752         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14753
14754         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14755                                            alc269_ignore);
14756         if (err < 0)
14757                 return err;
14758
14759         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14760         if (err < 0)
14761                 return err;
14762         if (spec->codec_variant == ALC269_TYPE_NORMAL)
14763                 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14764         else
14765                 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14766                                                  0x22, 0);
14767         if (err < 0)
14768                 return err;
14769
14770         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14771
14772         alc_auto_parse_digital(codec);
14773
14774         if (spec->kctls.list)
14775                 add_mixer(spec, spec->kctls.list);
14776
14777         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14778                 add_verb(spec, alc269vb_init_verbs);
14779                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14780         } else {
14781                 add_verb(spec, alc269_init_verbs);
14782                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14783         }
14784
14785         spec->num_mux_defs = 1;
14786         spec->input_mux = &spec->private_imux[0];
14787
14788         if (!alc275_setup_dual_adc(codec))
14789                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14790                                      sizeof(alc269_adc_candidates));
14791
14792         /* set default input source */
14793         if (!spec->dual_adc_switch)
14794                 select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14795                                         spec->input_mux->items[0].index);
14796
14797         err = alc_auto_add_mic_boost(codec);
14798         if (err < 0)
14799                 return err;
14800
14801         if (!spec->cap_mixer && !spec->no_analog)
14802                 set_capture_mixer(codec);
14803
14804         return 1;
14805 }
14806
14807 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14808 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14809 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14810
14811
14812 /* init callback for auto-configuration model -- overriding the default init */
14813 static void alc269_auto_init(struct hda_codec *codec)
14814 {
14815         struct alc_spec *spec = codec->spec;
14816         alc269_auto_init_multi_out(codec);
14817         alc269_auto_init_hp_out(codec);
14818         alc269_auto_init_analog_input(codec);
14819         alc_auto_init_digital(codec);
14820         if (spec->unsol_event)
14821                 alc_inithook(codec);
14822 }
14823
14824 #ifdef SND_HDA_NEEDS_RESUME
14825 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14826 {
14827         int val = alc_read_coef_idx(codec, 0x04);
14828         if (power_up)
14829                 val |= 1 << 11;
14830         else
14831                 val &= ~(1 << 11);
14832         alc_write_coef_idx(codec, 0x04, val);
14833 }
14834
14835 #ifdef CONFIG_SND_HDA_POWER_SAVE
14836 static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14837 {
14838         struct alc_spec *spec = codec->spec;
14839
14840         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14841                 alc269_toggle_power_output(codec, 0);
14842         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14843                 alc269_toggle_power_output(codec, 0);
14844                 msleep(150);
14845         }
14846
14847         alc_shutup(codec);
14848         if (spec && spec->power_hook)
14849                 spec->power_hook(codec);
14850         return 0;
14851 }
14852 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14853
14854 static int alc269_resume(struct hda_codec *codec)
14855 {
14856         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14857                 alc269_toggle_power_output(codec, 0);
14858                 msleep(150);
14859         }
14860
14861         codec->patch_ops.init(codec);
14862
14863         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14864                 alc269_toggle_power_output(codec, 1);
14865                 msleep(200);
14866         }
14867
14868         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14869                 alc269_toggle_power_output(codec, 1);
14870
14871         snd_hda_codec_resume_amp(codec);
14872         snd_hda_codec_resume_cache(codec);
14873         hda_call_check_power_status(codec, 0x01);
14874         return 0;
14875 }
14876 #endif /* SND_HDA_NEEDS_RESUME */
14877
14878 static void alc269_fixup_hweq(struct hda_codec *codec,
14879                                const struct alc_fixup *fix, int action)
14880 {
14881         int coef;
14882
14883         if (action != ALC_FIXUP_ACT_INIT)
14884                 return;
14885         coef = alc_read_coef_idx(codec, 0x1e);
14886         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
14887 }
14888
14889 enum {
14890         ALC269_FIXUP_SONY_VAIO,
14891         ALC275_FIXUP_SONY_VAIO_GPIO2,
14892         ALC269_FIXUP_DELL_M101Z,
14893         ALC269_FIXUP_SKU_IGNORE,
14894         ALC269_FIXUP_ASUS_G73JW,
14895         ALC269_FIXUP_LENOVO_EAPD,
14896         ALC275_FIXUP_SONY_HWEQ,
14897 };
14898
14899 static const struct alc_fixup alc269_fixups[] = {
14900         [ALC269_FIXUP_SONY_VAIO] = {
14901                 .type = ALC_FIXUP_VERBS,
14902                 .v.verbs = (const struct hda_verb[]) {
14903                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14904                         {}
14905                 }
14906         },
14907         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
14908                 .type = ALC_FIXUP_VERBS,
14909                 .v.verbs = (const struct hda_verb[]) {
14910                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14911                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14912                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14913                         { }
14914                 },
14915                 .chained = true,
14916                 .chain_id = ALC269_FIXUP_SONY_VAIO
14917         },
14918         [ALC269_FIXUP_DELL_M101Z] = {
14919                 .type = ALC_FIXUP_VERBS,
14920                 .v.verbs = (const struct hda_verb[]) {
14921                         /* Enables internal speaker */
14922                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
14923                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14924                         {}
14925                 }
14926         },
14927         [ALC269_FIXUP_SKU_IGNORE] = {
14928                 .type = ALC_FIXUP_SKU,
14929                 .v.sku = ALC_FIXUP_SKU_IGNORE,
14930         },
14931         [ALC269_FIXUP_ASUS_G73JW] = {
14932                 .type = ALC_FIXUP_PINS,
14933                 .v.pins = (const struct alc_pincfg[]) {
14934                         { 0x17, 0x99130111 }, /* subwoofer */
14935                         { }
14936                 }
14937         },
14938         [ALC269_FIXUP_LENOVO_EAPD] = {
14939                 .type = ALC_FIXUP_VERBS,
14940                 .v.verbs = (const struct hda_verb[]) {
14941                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
14942                         {}
14943                 }
14944         },
14945         [ALC275_FIXUP_SONY_HWEQ] = {
14946                 .type = ALC_FIXUP_FUNC,
14947                 .v.func = alc269_fixup_hweq,
14948                 .chained = true,
14949                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
14950         }
14951 };
14952
14953 static struct snd_pci_quirk alc269_fixup_tbl[] = {
14954         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
14955         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14956         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14957         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14958         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14959         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14960         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14961         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14962         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
14963         {}
14964 };
14965
14966
14967 /*
14968  * configuration and preset
14969  */
14970 static const char * const alc269_models[ALC269_MODEL_LAST] = {
14971         [ALC269_BASIC]                  = "basic",
14972         [ALC269_QUANTA_FL1]             = "quanta",
14973         [ALC269_AMIC]                   = "laptop-amic",
14974         [ALC269_DMIC]                   = "laptop-dmic",
14975         [ALC269_FUJITSU]                = "fujitsu",
14976         [ALC269_LIFEBOOK]               = "lifebook",
14977         [ALC269_AUTO]                   = "auto",
14978 };
14979
14980 static struct snd_pci_quirk alc269_cfg_tbl[] = {
14981         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14982         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14983         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14984                       ALC269_AMIC),
14985         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14986         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14987         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14988         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14989         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14990         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14991         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14992         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14993         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14994         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14995         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14996         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14997         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14998         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14999         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
15000         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
15001         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
15002         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
15003         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
15004         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
15005         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
15006         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
15007         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
15008         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
15009         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
15010         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
15011         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
15012         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
15013         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
15014         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
15015         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
15016         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
15017         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
15018         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
15019         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
15020         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
15021         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
15022                       ALC269_DMIC),
15023         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
15024                       ALC269_DMIC),
15025         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
15026         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
15027         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
15028         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
15029         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
15030         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
15031         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
15032         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
15033         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
15034         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
15035         {}
15036 };
15037
15038 static struct alc_config_preset alc269_presets[] = {
15039         [ALC269_BASIC] = {
15040                 .mixers = { alc269_base_mixer },
15041                 .init_verbs = { alc269_init_verbs },
15042                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15043                 .dac_nids = alc269_dac_nids,
15044                 .hp_nid = 0x03,
15045                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15046                 .channel_mode = alc269_modes,
15047                 .input_mux = &alc269_capture_source,
15048         },
15049         [ALC269_QUANTA_FL1] = {
15050                 .mixers = { alc269_quanta_fl1_mixer },
15051                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
15052                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15053                 .dac_nids = alc269_dac_nids,
15054                 .hp_nid = 0x03,
15055                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15056                 .channel_mode = alc269_modes,
15057                 .input_mux = &alc269_capture_source,
15058                 .unsol_event = alc269_quanta_fl1_unsol_event,
15059                 .setup = alc269_quanta_fl1_setup,
15060                 .init_hook = alc269_quanta_fl1_init_hook,
15061         },
15062         [ALC269_AMIC] = {
15063                 .mixers = { alc269_laptop_mixer },
15064                 .cap_mixer = alc269_laptop_analog_capture_mixer,
15065                 .init_verbs = { alc269_init_verbs,
15066                                 alc269_laptop_amic_init_verbs },
15067                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15068                 .dac_nids = alc269_dac_nids,
15069                 .hp_nid = 0x03,
15070                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15071                 .channel_mode = alc269_modes,
15072                 .unsol_event = alc269_laptop_unsol_event,
15073                 .setup = alc269_laptop_amic_setup,
15074                 .init_hook = alc269_laptop_inithook,
15075         },
15076         [ALC269_DMIC] = {
15077                 .mixers = { alc269_laptop_mixer },
15078                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15079                 .init_verbs = { alc269_init_verbs,
15080                                 alc269_laptop_dmic_init_verbs },
15081                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15082                 .dac_nids = alc269_dac_nids,
15083                 .hp_nid = 0x03,
15084                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15085                 .channel_mode = alc269_modes,
15086                 .unsol_event = alc269_laptop_unsol_event,
15087                 .setup = alc269_laptop_dmic_setup,
15088                 .init_hook = alc269_laptop_inithook,
15089         },
15090         [ALC269VB_AMIC] = {
15091                 .mixers = { alc269vb_laptop_mixer },
15092                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
15093                 .init_verbs = { alc269vb_init_verbs,
15094                                 alc269vb_laptop_amic_init_verbs },
15095                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15096                 .dac_nids = alc269_dac_nids,
15097                 .hp_nid = 0x03,
15098                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15099                 .channel_mode = alc269_modes,
15100                 .unsol_event = alc269_laptop_unsol_event,
15101                 .setup = alc269vb_laptop_amic_setup,
15102                 .init_hook = alc269_laptop_inithook,
15103         },
15104         [ALC269VB_DMIC] = {
15105                 .mixers = { alc269vb_laptop_mixer },
15106                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15107                 .init_verbs = { alc269vb_init_verbs,
15108                                 alc269vb_laptop_dmic_init_verbs },
15109                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15110                 .dac_nids = alc269_dac_nids,
15111                 .hp_nid = 0x03,
15112                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15113                 .channel_mode = alc269_modes,
15114                 .unsol_event = alc269_laptop_unsol_event,
15115                 .setup = alc269vb_laptop_dmic_setup,
15116                 .init_hook = alc269_laptop_inithook,
15117         },
15118         [ALC269_FUJITSU] = {
15119                 .mixers = { alc269_fujitsu_mixer },
15120                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15121                 .init_verbs = { alc269_init_verbs,
15122                                 alc269_laptop_dmic_init_verbs },
15123                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15124                 .dac_nids = alc269_dac_nids,
15125                 .hp_nid = 0x03,
15126                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15127                 .channel_mode = alc269_modes,
15128                 .unsol_event = alc269_laptop_unsol_event,
15129                 .setup = alc269_laptop_dmic_setup,
15130                 .init_hook = alc269_laptop_inithook,
15131         },
15132         [ALC269_LIFEBOOK] = {
15133                 .mixers = { alc269_lifebook_mixer },
15134                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15135                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15136                 .dac_nids = alc269_dac_nids,
15137                 .hp_nid = 0x03,
15138                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15139                 .channel_mode = alc269_modes,
15140                 .input_mux = &alc269_capture_source,
15141                 .unsol_event = alc269_lifebook_unsol_event,
15142                 .init_hook = alc269_lifebook_init_hook,
15143         },
15144         [ALC271_ACER] = {
15145                 .mixers = { alc269_asus_mixer },
15146                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15147                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15148                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15149                 .dac_nids = alc269_dac_nids,
15150                 .adc_nids = alc262_dmic_adc_nids,
15151                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15152                 .capsrc_nids = alc262_dmic_capsrc_nids,
15153                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15154                 .channel_mode = alc269_modes,
15155                 .input_mux = &alc269_capture_source,
15156                 .dig_out_nid = ALC880_DIGOUT_NID,
15157                 .unsol_event = alc_sku_unsol_event,
15158                 .setup = alc269vb_laptop_dmic_setup,
15159                 .init_hook = alc_inithook,
15160         },
15161 };
15162
15163 static int alc269_fill_coef(struct hda_codec *codec)
15164 {
15165         int val;
15166
15167         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15168                 alc_write_coef_idx(codec, 0xf, 0x960b);
15169                 alc_write_coef_idx(codec, 0xe, 0x8817);
15170         }
15171
15172         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15173                 alc_write_coef_idx(codec, 0xf, 0x960b);
15174                 alc_write_coef_idx(codec, 0xe, 0x8814);
15175         }
15176
15177         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15178                 val = alc_read_coef_idx(codec, 0x04);
15179                 /* Power up output pin */
15180                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15181         }
15182
15183         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15184                 val = alc_read_coef_idx(codec, 0xd);
15185                 if ((val & 0x0c00) >> 10 != 0x1) {
15186                         /* Capless ramp up clock control */
15187                         alc_write_coef_idx(codec, 0xd, val | 1<<10);
15188                 }
15189                 val = alc_read_coef_idx(codec, 0x17);
15190                 if ((val & 0x01c0) >> 6 != 0x4) {
15191                         /* Class D power on reset */
15192                         alc_write_coef_idx(codec, 0x17, val | 1<<7);
15193                 }
15194         }
15195         return 0;
15196 }
15197
15198 static int patch_alc269(struct hda_codec *codec)
15199 {
15200         struct alc_spec *spec;
15201         int board_config, coef;
15202         int err;
15203
15204         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15205         if (spec == NULL)
15206                 return -ENOMEM;
15207
15208         codec->spec = spec;
15209
15210         alc_auto_parse_customize_define(codec);
15211
15212         if (codec->vendor_id == 0x10ec0269) {
15213                 coef = alc_read_coef_idx(codec, 0);
15214                 if ((coef & 0x00f0) == 0x0010) {
15215                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15216                             spec->cdefine.platform_type == 1) {
15217                                 alc_codec_rename(codec, "ALC271X");
15218                                 spec->codec_variant = ALC269_TYPE_ALC271X;
15219                         } else if ((coef & 0xf000) == 0x1000) {
15220                                 spec->codec_variant = ALC269_TYPE_ALC270;
15221                         } else if ((coef & 0xf000) == 0x2000) {
15222                                 alc_codec_rename(codec, "ALC259");
15223                                 spec->codec_variant = ALC269_TYPE_ALC259;
15224                         } else if ((coef & 0xf000) == 0x3000) {
15225                                 alc_codec_rename(codec, "ALC258");
15226                                 spec->codec_variant = ALC269_TYPE_ALC258;
15227                         } else {
15228                                 alc_codec_rename(codec, "ALC269VB");
15229                                 spec->codec_variant = ALC269_TYPE_ALC269VB;
15230                         }
15231                 } else
15232                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
15233                 alc269_fill_coef(codec);
15234         }
15235
15236         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15237                                                   alc269_models,
15238                                                   alc269_cfg_tbl);
15239
15240         if (board_config < 0) {
15241                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15242                        codec->chip_name);
15243                 board_config = ALC269_AUTO;
15244         }
15245
15246         if (board_config == ALC269_AUTO) {
15247                 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
15248                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
15249         }
15250
15251         if (board_config == ALC269_AUTO) {
15252                 /* automatic parse from the BIOS config */
15253                 err = alc269_parse_auto_config(codec);
15254                 if (err < 0) {
15255                         alc_free(codec);
15256                         return err;
15257                 } else if (!err) {
15258                         printk(KERN_INFO
15259                                "hda_codec: Cannot set up configuration "
15260                                "from BIOS.  Using base mode...\n");
15261                         board_config = ALC269_BASIC;
15262                 }
15263         }
15264
15265         if (has_cdefine_beep(codec)) {
15266                 err = snd_hda_attach_beep_device(codec, 0x1);
15267                 if (err < 0) {
15268                         alc_free(codec);
15269                         return err;
15270                 }
15271         }
15272
15273         if (board_config != ALC269_AUTO)
15274                 setup_preset(codec, &alc269_presets[board_config]);
15275
15276         if (board_config == ALC269_QUANTA_FL1) {
15277                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15278                  * fix the sample rate of analog I/O to 44.1kHz
15279                  */
15280                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15281                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15282         } else if (spec->dual_adc_switch) {
15283                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15284                 /* switch ADC dynamically */
15285                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15286         } else {
15287                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15288                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15289         }
15290         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15291         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15292
15293         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15294                 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15295                         spec->adc_nids = alc269_adc_nids;
15296                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15297                         spec->capsrc_nids = alc269_capsrc_nids;
15298                 } else {
15299                         spec->adc_nids = alc269vb_adc_nids;
15300                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15301                         spec->capsrc_nids = alc269vb_capsrc_nids;
15302                 }
15303         }
15304
15305         if (!spec->cap_mixer)
15306                 set_capture_mixer(codec);
15307         if (has_cdefine_beep(codec))
15308                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15309
15310         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
15311
15312         spec->vmaster_nid = 0x02;
15313
15314         codec->patch_ops = alc_patch_ops;
15315 #ifdef CONFIG_SND_HDA_POWER_SAVE
15316         codec->patch_ops.suspend = alc269_suspend;
15317 #endif
15318 #ifdef SND_HDA_NEEDS_RESUME
15319         codec->patch_ops.resume = alc269_resume;
15320 #endif
15321         if (board_config == ALC269_AUTO)
15322                 spec->init_hook = alc269_auto_init;
15323
15324         alc_init_jacks(codec);
15325 #ifdef CONFIG_SND_HDA_POWER_SAVE
15326         if (!spec->loopback.amplist)
15327                 spec->loopback.amplist = alc269_loopbacks;
15328         if (alc269_mic2_for_mute_led(codec))
15329                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15330 #endif
15331
15332         return 0;
15333 }
15334
15335 /*
15336  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15337  */
15338
15339 /*
15340  * set the path ways for 2 channel output
15341  * need to set the codec line out and mic 1 pin widgets to inputs
15342  */
15343 static struct hda_verb alc861_threestack_ch2_init[] = {
15344         /* set pin widget 1Ah (line in) for input */
15345         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15346         /* set pin widget 18h (mic1/2) for input, for mic also enable
15347          * the vref
15348          */
15349         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15350
15351         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15352 #if 0
15353         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15354         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15355 #endif
15356         { } /* end */
15357 };
15358 /*
15359  * 6ch mode
15360  * need to set the codec line out and mic 1 pin widgets to outputs
15361  */
15362 static struct hda_verb alc861_threestack_ch6_init[] = {
15363         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15364         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15365         /* set pin widget 18h (mic1) for output (CLFE)*/
15366         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15367
15368         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15369         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15370
15371         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15372 #if 0
15373         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15374         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15375 #endif
15376         { } /* end */
15377 };
15378
15379 static struct hda_channel_mode alc861_threestack_modes[2] = {
15380         { 2, alc861_threestack_ch2_init },
15381         { 6, alc861_threestack_ch6_init },
15382 };
15383 /* Set mic1 as input and unmute the mixer */
15384 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15385         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15386         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15387         { } /* end */
15388 };
15389 /* Set mic1 as output and mute mixer */
15390 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15391         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15392         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15393         { } /* end */
15394 };
15395
15396 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15397         { 2, alc861_uniwill_m31_ch2_init },
15398         { 4, alc861_uniwill_m31_ch4_init },
15399 };
15400
15401 /* Set mic1 and line-in as input and unmute the mixer */
15402 static struct hda_verb alc861_asus_ch2_init[] = {
15403         /* set pin widget 1Ah (line in) for input */
15404         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15405         /* set pin widget 18h (mic1/2) for input, for mic also enable
15406          * the vref
15407          */
15408         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15409
15410         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15411 #if 0
15412         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15413         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15414 #endif
15415         { } /* end */
15416 };
15417 /* Set mic1 nad line-in as output and mute mixer */
15418 static struct hda_verb alc861_asus_ch6_init[] = {
15419         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15420         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15421         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15422         /* set pin widget 18h (mic1) for output (CLFE)*/
15423         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15424         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15425         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15426         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15427
15428         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15429 #if 0
15430         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15431         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15432 #endif
15433         { } /* end */
15434 };
15435
15436 static struct hda_channel_mode alc861_asus_modes[2] = {
15437         { 2, alc861_asus_ch2_init },
15438         { 6, alc861_asus_ch6_init },
15439 };
15440
15441 /* patch-ALC861 */
15442
15443 static struct snd_kcontrol_new alc861_base_mixer[] = {
15444         /* output mixer control */
15445         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15446         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15447         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15448         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15449         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15450
15451         /*Input mixer control */
15452         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15453            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15454         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15455         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15456         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15457         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15458         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15459         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15460         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15461         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15462
15463         { } /* end */
15464 };
15465
15466 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15467         /* output mixer control */
15468         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15469         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15470         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15471         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15472         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15473
15474         /* Input mixer control */
15475         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15476            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15477         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15478         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15479         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15480         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15481         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15482         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15483         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15484         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15485
15486         {
15487                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15488                 .name = "Channel Mode",
15489                 .info = alc_ch_mode_info,
15490                 .get = alc_ch_mode_get,
15491                 .put = alc_ch_mode_put,
15492                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15493         },
15494         { } /* end */
15495 };
15496
15497 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15498         /* output mixer control */
15499         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15500         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15501         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15502
15503         { } /* end */
15504 };
15505
15506 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15507         /* output mixer control */
15508         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15509         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15510         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15511         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15512         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15513
15514         /* Input mixer control */
15515         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15516            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15517         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15518         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15519         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15520         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15521         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15522         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15523         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15524         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15525
15526         {
15527                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15528                 .name = "Channel Mode",
15529                 .info = alc_ch_mode_info,
15530                 .get = alc_ch_mode_get,
15531                 .put = alc_ch_mode_put,
15532                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15533         },
15534         { } /* end */
15535 };
15536
15537 static struct snd_kcontrol_new alc861_asus_mixer[] = {
15538         /* output mixer control */
15539         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15540         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15541         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15542         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15543         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15544
15545         /* Input mixer control */
15546         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15547         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15548         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15549         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15550         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15551         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15552         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15553         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15554         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15555         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15556
15557         {
15558                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15559                 .name = "Channel Mode",
15560                 .info = alc_ch_mode_info,
15561                 .get = alc_ch_mode_get,
15562                 .put = alc_ch_mode_put,
15563                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15564         },
15565         { }
15566 };
15567
15568 /* additional mixer */
15569 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15570         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15571         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15572         { }
15573 };
15574
15575 /*
15576  * generic initialization of ADC, input mixers and output mixers
15577  */
15578 static struct hda_verb alc861_base_init_verbs[] = {
15579         /*
15580          * Unmute ADC0 and set the default input to mic-in
15581          */
15582         /* port-A for surround (rear panel) */
15583         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15584         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15585         /* port-B for mic-in (rear panel) with vref */
15586         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15587         /* port-C for line-in (rear panel) */
15588         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15589         /* port-D for Front */
15590         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15591         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15592         /* port-E for HP out (front panel) */
15593         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15594         /* route front PCM to HP */
15595         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15596         /* port-F for mic-in (front panel) with vref */
15597         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15598         /* port-G for CLFE (rear panel) */
15599         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15600         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15601         /* port-H for side (rear panel) */
15602         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15603         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15604         /* CD-in */
15605         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15606         /* route front mic to ADC1*/
15607         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15608         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15609
15610         /* Unmute DAC0~3 & spdif out*/
15611         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15612         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15613         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15614         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15615         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15616
15617         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15618         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15619         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15620         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15621         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15622
15623         /* Unmute Stereo Mixer 15 */
15624         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15625         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15626         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15627         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15628
15629         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15630         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15631         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15632         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15633         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15634         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15635         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15636         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15637         /* hp used DAC 3 (Front) */
15638         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15639         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15640
15641         { }
15642 };
15643
15644 static struct hda_verb alc861_threestack_init_verbs[] = {
15645         /*
15646          * Unmute ADC0 and set the default input to mic-in
15647          */
15648         /* port-A for surround (rear panel) */
15649         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15650         /* port-B for mic-in (rear panel) with vref */
15651         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15652         /* port-C for line-in (rear panel) */
15653         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15654         /* port-D for Front */
15655         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15656         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15657         /* port-E for HP out (front panel) */
15658         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15659         /* route front PCM to HP */
15660         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15661         /* port-F for mic-in (front panel) with vref */
15662         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15663         /* port-G for CLFE (rear panel) */
15664         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15665         /* port-H for side (rear panel) */
15666         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15667         /* CD-in */
15668         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15669         /* route front mic to ADC1*/
15670         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15671         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15672         /* Unmute DAC0~3 & spdif out*/
15673         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15674         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15675         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15676         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15677         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15678
15679         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15680         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15681         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15682         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15683         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15684
15685         /* Unmute Stereo Mixer 15 */
15686         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15687         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15688         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15689         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15690
15691         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15692         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15693         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15694         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15695         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15696         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15697         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15698         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15699         /* hp used DAC 3 (Front) */
15700         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15701         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15702         { }
15703 };
15704
15705 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15706         /*
15707          * Unmute ADC0 and set the default input to mic-in
15708          */
15709         /* port-A for surround (rear panel) */
15710         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15711         /* port-B for mic-in (rear panel) with vref */
15712         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15713         /* port-C for line-in (rear panel) */
15714         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15715         /* port-D for Front */
15716         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15717         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15718         /* port-E for HP out (front panel) */
15719         /* this has to be set to VREF80 */
15720         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15721         /* route front PCM to HP */
15722         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15723         /* port-F for mic-in (front panel) with vref */
15724         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15725         /* port-G for CLFE (rear panel) */
15726         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15727         /* port-H for side (rear panel) */
15728         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15729         /* CD-in */
15730         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15731         /* route front mic to ADC1*/
15732         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15733         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15734         /* Unmute DAC0~3 & spdif out*/
15735         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15736         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15737         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15738         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15739         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15740
15741         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15742         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15743         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15744         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15745         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15746
15747         /* Unmute Stereo Mixer 15 */
15748         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15749         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15750         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15751         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15752
15753         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15754         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15755         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15756         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15757         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15758         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15759         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15760         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15761         /* hp used DAC 3 (Front) */
15762         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15763         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15764         { }
15765 };
15766
15767 static struct hda_verb alc861_asus_init_verbs[] = {
15768         /*
15769          * Unmute ADC0 and set the default input to mic-in
15770          */
15771         /* port-A for surround (rear panel)
15772          * according to codec#0 this is the HP jack
15773          */
15774         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15775         /* route front PCM to HP */
15776         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15777         /* port-B for mic-in (rear panel) with vref */
15778         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15779         /* port-C for line-in (rear panel) */
15780         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15781         /* port-D for Front */
15782         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15783         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15784         /* port-E for HP out (front panel) */
15785         /* this has to be set to VREF80 */
15786         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15787         /* route front PCM to HP */
15788         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15789         /* port-F for mic-in (front panel) with vref */
15790         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15791         /* port-G for CLFE (rear panel) */
15792         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15793         /* port-H for side (rear panel) */
15794         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15795         /* CD-in */
15796         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15797         /* route front mic to ADC1*/
15798         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15799         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15800         /* Unmute DAC0~3 & spdif out*/
15801         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15802         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15803         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15804         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15805         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15806         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15807         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15808         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15809         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15810         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15811
15812         /* Unmute Stereo Mixer 15 */
15813         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15814         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15815         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15816         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15817
15818         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15819         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15820         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15821         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15822         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15823         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15824         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15825         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15826         /* hp used DAC 3 (Front) */
15827         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15828         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15829         { }
15830 };
15831
15832 /* additional init verbs for ASUS laptops */
15833 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15834         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15835         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15836         { }
15837 };
15838
15839 /*
15840  * generic initialization of ADC, input mixers and output mixers
15841  */
15842 static struct hda_verb alc861_auto_init_verbs[] = {
15843         /*
15844          * Unmute ADC0 and set the default input to mic-in
15845          */
15846         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15847         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15848
15849         /* Unmute DAC0~3 & spdif out*/
15850         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15851         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15852         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15853         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15854         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15855
15856         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15857         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15858         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15859         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15860         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15861
15862         /* Unmute Stereo Mixer 15 */
15863         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15864         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15865         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15866         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15867
15868         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15869         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15870         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15871         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15872         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15873         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15874         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15875         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15876
15877         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15878         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15879         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15880         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15881         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15882         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15883         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15884         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15885
15886         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15887
15888         { }
15889 };
15890
15891 static struct hda_verb alc861_toshiba_init_verbs[] = {
15892         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15893
15894         { }
15895 };
15896
15897 /* toggle speaker-output according to the hp-jack state */
15898 static void alc861_toshiba_automute(struct hda_codec *codec)
15899 {
15900         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15901
15902         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15903                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15904         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15905                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15906 }
15907
15908 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15909                                        unsigned int res)
15910 {
15911         if ((res >> 26) == ALC880_HP_EVENT)
15912                 alc861_toshiba_automute(codec);
15913 }
15914
15915 /* pcm configuration: identical with ALC880 */
15916 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15917 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15918 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15919 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15920
15921
15922 #define ALC861_DIGOUT_NID       0x07
15923
15924 static struct hda_channel_mode alc861_8ch_modes[1] = {
15925         { 8, NULL }
15926 };
15927
15928 static hda_nid_t alc861_dac_nids[4] = {
15929         /* front, surround, clfe, side */
15930         0x03, 0x06, 0x05, 0x04
15931 };
15932
15933 static hda_nid_t alc660_dac_nids[3] = {
15934         /* front, clfe, surround */
15935         0x03, 0x05, 0x06
15936 };
15937
15938 static hda_nid_t alc861_adc_nids[1] = {
15939         /* ADC0-2 */
15940         0x08,
15941 };
15942
15943 static struct hda_input_mux alc861_capture_source = {
15944         .num_items = 5,
15945         .items = {
15946                 { "Mic", 0x0 },
15947                 { "Front Mic", 0x3 },
15948                 { "Line", 0x1 },
15949                 { "CD", 0x4 },
15950                 { "Mixer", 0x5 },
15951         },
15952 };
15953
15954 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15955 {
15956         struct alc_spec *spec = codec->spec;
15957         hda_nid_t mix, srcs[5];
15958         int i, j, num;
15959
15960         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15961                 return 0;
15962         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15963         if (num < 0)
15964                 return 0;
15965         for (i = 0; i < num; i++) {
15966                 unsigned int type;
15967                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15968                 if (type != AC_WID_AUD_OUT)
15969                         continue;
15970                 for (j = 0; j < spec->multiout.num_dacs; j++)
15971                         if (spec->multiout.dac_nids[j] == srcs[i])
15972                                 break;
15973                 if (j >= spec->multiout.num_dacs)
15974                         return srcs[i];
15975         }
15976         return 0;
15977 }
15978
15979 /* fill in the dac_nids table from the parsed pin configuration */
15980 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15981                                      const struct auto_pin_cfg *cfg)
15982 {
15983         struct alc_spec *spec = codec->spec;
15984         int i;
15985         hda_nid_t nid, dac;
15986
15987         spec->multiout.dac_nids = spec->private_dac_nids;
15988         for (i = 0; i < cfg->line_outs; i++) {
15989                 nid = cfg->line_out_pins[i];
15990                 dac = alc861_look_for_dac(codec, nid);
15991                 if (!dac)
15992                         continue;
15993                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15994         }
15995         return 0;
15996 }
15997
15998 static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15999                                   hda_nid_t nid, int idx, unsigned int chs)
16000 {
16001         return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
16002                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
16003 }
16004
16005 #define alc861_create_out_sw(codec, pfx, nid, chs) \
16006         __alc861_create_out_sw(codec, pfx, nid, 0, chs)
16007
16008 /* add playback controls from the parsed DAC table */
16009 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
16010                                              const struct auto_pin_cfg *cfg)
16011 {
16012         struct alc_spec *spec = codec->spec;
16013         static const char * const chname[4] = {
16014                 "Front", "Surround", NULL /*CLFE*/, "Side"
16015         };
16016         const char *pfx = alc_get_line_out_pfx(cfg, true);
16017         hda_nid_t nid;
16018         int i, err;
16019
16020         for (i = 0; i < cfg->line_outs; i++) {
16021                 nid = spec->multiout.dac_nids[i];
16022                 if (!nid)
16023                         continue;
16024                 if (!pfx && i == 2) {
16025                         /* Center/LFE */
16026                         err = alc861_create_out_sw(codec, "Center", nid, 1);
16027                         if (err < 0)
16028                                 return err;
16029                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
16030                         if (err < 0)
16031                                 return err;
16032                 } else {
16033                         const char *name = pfx;
16034                         if (!name)
16035                                 name = chname[i];
16036                         err = __alc861_create_out_sw(codec, name, nid, i, 3);
16037                         if (err < 0)
16038                                 return err;
16039                 }
16040         }
16041         return 0;
16042 }
16043
16044 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
16045 {
16046         struct alc_spec *spec = codec->spec;
16047         int err;
16048         hda_nid_t nid;
16049
16050         if (!pin)
16051                 return 0;
16052
16053         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
16054                 nid = alc861_look_for_dac(codec, pin);
16055                 if (nid) {
16056                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
16057                         if (err < 0)
16058                                 return err;
16059                         spec->multiout.hp_nid = nid;
16060                 }
16061         }
16062         return 0;
16063 }
16064
16065 /* create playback/capture controls for input pins */
16066 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
16067                                                 const struct auto_pin_cfg *cfg)
16068 {
16069         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
16070 }
16071
16072 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
16073                                               hda_nid_t nid,
16074                                               int pin_type, hda_nid_t dac)
16075 {
16076         hda_nid_t mix, srcs[5];
16077         int i, num;
16078
16079         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
16080                             pin_type);
16081         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16082                             AMP_OUT_UNMUTE);
16083         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
16084                 return;
16085         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
16086         if (num < 0)
16087                 return;
16088         for (i = 0; i < num; i++) {
16089                 unsigned int mute;
16090                 if (srcs[i] == dac || srcs[i] == 0x15)
16091                         mute = AMP_IN_UNMUTE(i);
16092                 else
16093                         mute = AMP_IN_MUTE(i);
16094                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16095                                     mute);
16096         }
16097 }
16098
16099 static void alc861_auto_init_multi_out(struct hda_codec *codec)
16100 {
16101         struct alc_spec *spec = codec->spec;
16102         int i;
16103
16104         for (i = 0; i < spec->autocfg.line_outs; i++) {
16105                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16106                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16107                 if (nid)
16108                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
16109                                                           spec->multiout.dac_nids[i]);
16110         }
16111 }
16112
16113 static void alc861_auto_init_hp_out(struct hda_codec *codec)
16114 {
16115         struct alc_spec *spec = codec->spec;
16116
16117         if (spec->autocfg.hp_outs)
16118                 alc861_auto_set_output_and_unmute(codec,
16119                                                   spec->autocfg.hp_pins[0],
16120                                                   PIN_HP,
16121                                                   spec->multiout.hp_nid);
16122         if (spec->autocfg.speaker_outs)
16123                 alc861_auto_set_output_and_unmute(codec,
16124                                                   spec->autocfg.speaker_pins[0],
16125                                                   PIN_OUT,
16126                                                   spec->multiout.dac_nids[0]);
16127 }
16128
16129 static void alc861_auto_init_analog_input(struct hda_codec *codec)
16130 {
16131         struct alc_spec *spec = codec->spec;
16132         struct auto_pin_cfg *cfg = &spec->autocfg;
16133         int i;
16134
16135         for (i = 0; i < cfg->num_inputs; i++) {
16136                 hda_nid_t nid = cfg->inputs[i].pin;
16137                 if (nid >= 0x0c && nid <= 0x11)
16138                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16139         }
16140 }
16141
16142 /* parse the BIOS configuration and set up the alc_spec */
16143 /* return 1 if successful, 0 if the proper config is not found,
16144  * or a negative error code
16145  */
16146 static int alc861_parse_auto_config(struct hda_codec *codec)
16147 {
16148         struct alc_spec *spec = codec->spec;
16149         int err;
16150         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16151
16152         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16153                                            alc861_ignore);
16154         if (err < 0)
16155                 return err;
16156         if (!spec->autocfg.line_outs)
16157                 return 0; /* can't find valid BIOS pin config */
16158
16159         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16160         if (err < 0)
16161                 return err;
16162         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16163         if (err < 0)
16164                 return err;
16165         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16166         if (err < 0)
16167                 return err;
16168         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16169         if (err < 0)
16170                 return err;
16171
16172         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16173
16174         alc_auto_parse_digital(codec);
16175
16176         if (spec->kctls.list)
16177                 add_mixer(spec, spec->kctls.list);
16178
16179         add_verb(spec, alc861_auto_init_verbs);
16180
16181         spec->num_mux_defs = 1;
16182         spec->input_mux = &spec->private_imux[0];
16183
16184         spec->adc_nids = alc861_adc_nids;
16185         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16186         set_capture_mixer(codec);
16187
16188         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16189
16190         return 1;
16191 }
16192
16193 /* additional initialization for auto-configuration model */
16194 static void alc861_auto_init(struct hda_codec *codec)
16195 {
16196         struct alc_spec *spec = codec->spec;
16197         alc861_auto_init_multi_out(codec);
16198         alc861_auto_init_hp_out(codec);
16199         alc861_auto_init_analog_input(codec);
16200         alc_auto_init_digital(codec);
16201         if (spec->unsol_event)
16202                 alc_inithook(codec);
16203 }
16204
16205 #ifdef CONFIG_SND_HDA_POWER_SAVE
16206 static struct hda_amp_list alc861_loopbacks[] = {
16207         { 0x15, HDA_INPUT, 0 },
16208         { 0x15, HDA_INPUT, 1 },
16209         { 0x15, HDA_INPUT, 2 },
16210         { 0x15, HDA_INPUT, 3 },
16211         { } /* end */
16212 };
16213 #endif
16214
16215
16216 /*
16217  * configuration and preset
16218  */
16219 static const char * const alc861_models[ALC861_MODEL_LAST] = {
16220         [ALC861_3ST]            = "3stack",
16221         [ALC660_3ST]            = "3stack-660",
16222         [ALC861_3ST_DIG]        = "3stack-dig",
16223         [ALC861_6ST_DIG]        = "6stack-dig",
16224         [ALC861_UNIWILL_M31]    = "uniwill-m31",
16225         [ALC861_TOSHIBA]        = "toshiba",
16226         [ALC861_ASUS]           = "asus",
16227         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
16228         [ALC861_AUTO]           = "auto",
16229 };
16230
16231 static struct snd_pci_quirk alc861_cfg_tbl[] = {
16232         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16233         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16234         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16235         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16236         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16237         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16238         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16239         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16240          *        Any other models that need this preset?
16241          */
16242         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16243         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16244         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16245         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16246         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16247         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16248         /* FIXME: the below seems conflict */
16249         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16250         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16251         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16252         {}
16253 };
16254
16255 static struct alc_config_preset alc861_presets[] = {
16256         [ALC861_3ST] = {
16257                 .mixers = { alc861_3ST_mixer },
16258                 .init_verbs = { alc861_threestack_init_verbs },
16259                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16260                 .dac_nids = alc861_dac_nids,
16261                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16262                 .channel_mode = alc861_threestack_modes,
16263                 .need_dac_fix = 1,
16264                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16265                 .adc_nids = alc861_adc_nids,
16266                 .input_mux = &alc861_capture_source,
16267         },
16268         [ALC861_3ST_DIG] = {
16269                 .mixers = { alc861_base_mixer },
16270                 .init_verbs = { alc861_threestack_init_verbs },
16271                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16272                 .dac_nids = alc861_dac_nids,
16273                 .dig_out_nid = ALC861_DIGOUT_NID,
16274                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16275                 .channel_mode = alc861_threestack_modes,
16276                 .need_dac_fix = 1,
16277                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16278                 .adc_nids = alc861_adc_nids,
16279                 .input_mux = &alc861_capture_source,
16280         },
16281         [ALC861_6ST_DIG] = {
16282                 .mixers = { alc861_base_mixer },
16283                 .init_verbs = { alc861_base_init_verbs },
16284                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16285                 .dac_nids = alc861_dac_nids,
16286                 .dig_out_nid = ALC861_DIGOUT_NID,
16287                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16288                 .channel_mode = alc861_8ch_modes,
16289                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16290                 .adc_nids = alc861_adc_nids,
16291                 .input_mux = &alc861_capture_source,
16292         },
16293         [ALC660_3ST] = {
16294                 .mixers = { alc861_3ST_mixer },
16295                 .init_verbs = { alc861_threestack_init_verbs },
16296                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16297                 .dac_nids = alc660_dac_nids,
16298                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16299                 .channel_mode = alc861_threestack_modes,
16300                 .need_dac_fix = 1,
16301                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16302                 .adc_nids = alc861_adc_nids,
16303                 .input_mux = &alc861_capture_source,
16304         },
16305         [ALC861_UNIWILL_M31] = {
16306                 .mixers = { alc861_uniwill_m31_mixer },
16307                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16308                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16309                 .dac_nids = alc861_dac_nids,
16310                 .dig_out_nid = ALC861_DIGOUT_NID,
16311                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16312                 .channel_mode = alc861_uniwill_m31_modes,
16313                 .need_dac_fix = 1,
16314                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16315                 .adc_nids = alc861_adc_nids,
16316                 .input_mux = &alc861_capture_source,
16317         },
16318         [ALC861_TOSHIBA] = {
16319                 .mixers = { alc861_toshiba_mixer },
16320                 .init_verbs = { alc861_base_init_verbs,
16321                                 alc861_toshiba_init_verbs },
16322                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16323                 .dac_nids = alc861_dac_nids,
16324                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16325                 .channel_mode = alc883_3ST_2ch_modes,
16326                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16327                 .adc_nids = alc861_adc_nids,
16328                 .input_mux = &alc861_capture_source,
16329                 .unsol_event = alc861_toshiba_unsol_event,
16330                 .init_hook = alc861_toshiba_automute,
16331         },
16332         [ALC861_ASUS] = {
16333                 .mixers = { alc861_asus_mixer },
16334                 .init_verbs = { alc861_asus_init_verbs },
16335                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16336                 .dac_nids = alc861_dac_nids,
16337                 .dig_out_nid = ALC861_DIGOUT_NID,
16338                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16339                 .channel_mode = alc861_asus_modes,
16340                 .need_dac_fix = 1,
16341                 .hp_nid = 0x06,
16342                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16343                 .adc_nids = alc861_adc_nids,
16344                 .input_mux = &alc861_capture_source,
16345         },
16346         [ALC861_ASUS_LAPTOP] = {
16347                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16348                 .init_verbs = { alc861_asus_init_verbs,
16349                                 alc861_asus_laptop_init_verbs },
16350                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16351                 .dac_nids = alc861_dac_nids,
16352                 .dig_out_nid = ALC861_DIGOUT_NID,
16353                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16354                 .channel_mode = alc883_3ST_2ch_modes,
16355                 .need_dac_fix = 1,
16356                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16357                 .adc_nids = alc861_adc_nids,
16358                 .input_mux = &alc861_capture_source,
16359         },
16360 };
16361
16362 /* Pin config fixes */
16363 enum {
16364         PINFIX_FSC_AMILO_PI1505,
16365 };
16366
16367 static const struct alc_fixup alc861_fixups[] = {
16368         [PINFIX_FSC_AMILO_PI1505] = {
16369                 .type = ALC_FIXUP_PINS,
16370                 .v.pins = (const struct alc_pincfg[]) {
16371                         { 0x0b, 0x0221101f }, /* HP */
16372                         { 0x0f, 0x90170310 }, /* speaker */
16373                         { }
16374                 }
16375         },
16376 };
16377
16378 static struct snd_pci_quirk alc861_fixup_tbl[] = {
16379         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16380         {}
16381 };
16382
16383 static int patch_alc861(struct hda_codec *codec)
16384 {
16385         struct alc_spec *spec;
16386         int board_config;
16387         int err;
16388
16389         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16390         if (spec == NULL)
16391                 return -ENOMEM;
16392
16393         codec->spec = spec;
16394
16395         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16396                                                   alc861_models,
16397                                                   alc861_cfg_tbl);
16398
16399         if (board_config < 0) {
16400                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16401                        codec->chip_name);
16402                 board_config = ALC861_AUTO;
16403         }
16404
16405         if (board_config == ALC861_AUTO) {
16406                 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
16407                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
16408         }
16409
16410         if (board_config == ALC861_AUTO) {
16411                 /* automatic parse from the BIOS config */
16412                 err = alc861_parse_auto_config(codec);
16413                 if (err < 0) {
16414                         alc_free(codec);
16415                         return err;
16416                 } else if (!err) {
16417                         printk(KERN_INFO
16418                                "hda_codec: Cannot set up configuration "
16419                                "from BIOS.  Using base mode...\n");
16420                    board_config = ALC861_3ST_DIG;
16421                 }
16422         }
16423
16424         err = snd_hda_attach_beep_device(codec, 0x23);
16425         if (err < 0) {
16426                 alc_free(codec);
16427                 return err;
16428         }
16429
16430         if (board_config != ALC861_AUTO)
16431                 setup_preset(codec, &alc861_presets[board_config]);
16432
16433         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16434         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16435
16436         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16437         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16438
16439         if (!spec->cap_mixer)
16440                 set_capture_mixer(codec);
16441         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16442
16443         spec->vmaster_nid = 0x03;
16444
16445         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
16446
16447         codec->patch_ops = alc_patch_ops;
16448         if (board_config == ALC861_AUTO) {
16449                 spec->init_hook = alc861_auto_init;
16450 #ifdef CONFIG_SND_HDA_POWER_SAVE
16451                 spec->power_hook = alc_power_eapd;
16452 #endif
16453         }
16454 #ifdef CONFIG_SND_HDA_POWER_SAVE
16455         if (!spec->loopback.amplist)
16456                 spec->loopback.amplist = alc861_loopbacks;
16457 #endif
16458
16459         return 0;
16460 }
16461
16462 /*
16463  * ALC861-VD support
16464  *
16465  * Based on ALC882
16466  *
16467  * In addition, an independent DAC
16468  */
16469 #define ALC861VD_DIGOUT_NID     0x06
16470
16471 static hda_nid_t alc861vd_dac_nids[4] = {
16472         /* front, surr, clfe, side surr */
16473         0x02, 0x03, 0x04, 0x05
16474 };
16475
16476 /* dac_nids for ALC660vd are in a different order - according to
16477  * Realtek's driver.
16478  * This should probably result in a different mixer for 6stack models
16479  * of ALC660vd codecs, but for now there is only 3stack mixer
16480  * - and it is the same as in 861vd.
16481  * adc_nids in ALC660vd are (is) the same as in 861vd
16482  */
16483 static hda_nid_t alc660vd_dac_nids[3] = {
16484         /* front, rear, clfe, rear_surr */
16485         0x02, 0x04, 0x03
16486 };
16487
16488 static hda_nid_t alc861vd_adc_nids[1] = {
16489         /* ADC0 */
16490         0x09,
16491 };
16492
16493 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16494
16495 /* input MUX */
16496 /* FIXME: should be a matrix-type input source selection */
16497 static struct hda_input_mux alc861vd_capture_source = {
16498         .num_items = 4,
16499         .items = {
16500                 { "Mic", 0x0 },
16501                 { "Front Mic", 0x1 },
16502                 { "Line", 0x2 },
16503                 { "CD", 0x4 },
16504         },
16505 };
16506
16507 static struct hda_input_mux alc861vd_dallas_capture_source = {
16508         .num_items = 2,
16509         .items = {
16510                 { "Mic", 0x0 },
16511                 { "Internal Mic", 0x1 },
16512         },
16513 };
16514
16515 static struct hda_input_mux alc861vd_hp_capture_source = {
16516         .num_items = 2,
16517         .items = {
16518                 { "Front Mic", 0x0 },
16519                 { "ATAPI Mic", 0x1 },
16520         },
16521 };
16522
16523 /*
16524  * 2ch mode
16525  */
16526 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16527         { 2, NULL }
16528 };
16529
16530 /*
16531  * 6ch mode
16532  */
16533 static struct hda_verb alc861vd_6stack_ch6_init[] = {
16534         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16535         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16536         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16537         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16538         { } /* end */
16539 };
16540
16541 /*
16542  * 8ch mode
16543  */
16544 static struct hda_verb alc861vd_6stack_ch8_init[] = {
16545         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16546         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16547         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16548         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16549         { } /* end */
16550 };
16551
16552 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16553         { 6, alc861vd_6stack_ch6_init },
16554         { 8, alc861vd_6stack_ch8_init },
16555 };
16556
16557 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16558         {
16559                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16560                 .name = "Channel Mode",
16561                 .info = alc_ch_mode_info,
16562                 .get = alc_ch_mode_get,
16563                 .put = alc_ch_mode_put,
16564         },
16565         { } /* end */
16566 };
16567
16568 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16569  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16570  */
16571 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16572         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16573         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16574
16575         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16576         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16577
16578         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16579                                 HDA_OUTPUT),
16580         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16581                                 HDA_OUTPUT),
16582         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16583         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16584
16585         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16586         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16587
16588         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16589
16590         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16591         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16592         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16593
16594         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16595         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16596         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16597
16598         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16599         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16600
16601         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16602         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16603
16604         { } /* end */
16605 };
16606
16607 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16608         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16609         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16610
16611         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16612
16613         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16614         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16615         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16616
16617         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16618         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16619         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16620
16621         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16622         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16623
16624         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16625         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16626
16627         { } /* end */
16628 };
16629
16630 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16631         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16632         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16633         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16634
16635         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16636
16637         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16638         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16639         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16640
16641         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16642         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16643         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16644
16645         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16646         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16647
16648         { } /* end */
16649 };
16650
16651 /* Pin assignment: Speaker=0x14, HP = 0x15,
16652  *                 Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16653  */
16654 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16655         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16656         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16657         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16658         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16659         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16660         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16661         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16662         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
16663         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16664         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16665         { } /* end */
16666 };
16667
16668 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16669  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16670  */
16671 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16672         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16673         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16674         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16675         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16676         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16677         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16678         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16679         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16680
16681         { } /* end */
16682 };
16683
16684 /*
16685  * generic initialization of ADC, input mixers and output mixers
16686  */
16687 static struct hda_verb alc861vd_volume_init_verbs[] = {
16688         /*
16689          * Unmute ADC0 and set the default input to mic-in
16690          */
16691         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16692         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16693
16694         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16695          * the analog-loopback mixer widget
16696          */
16697         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16698         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16699         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16700         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16701         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16702         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16703
16704         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16705         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16706         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16707         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16708         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16709
16710         /*
16711          * Set up output mixers (0x02 - 0x05)
16712          */
16713         /* set vol=0 to output mixers */
16714         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16715         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16716         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16717         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16718
16719         /* set up input amps for analog loopback */
16720         /* Amp Indices: DAC = 0, mixer = 1 */
16721         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16722         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16723         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16724         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16725         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16726         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16727         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16728         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16729
16730         { }
16731 };
16732
16733 /*
16734  * 3-stack pin configuration:
16735  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16736  */
16737 static struct hda_verb alc861vd_3stack_init_verbs[] = {
16738         /*
16739          * Set pin mode and muting
16740          */
16741         /* set front pin widgets 0x14 for output */
16742         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16743         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16744         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16745
16746         /* Mic (rear) pin: input vref at 80% */
16747         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16748         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16749         /* Front Mic pin: input vref at 80% */
16750         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16751         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16752         /* Line In pin: input */
16753         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16754         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16755         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16756         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16757         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16758         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16759         /* CD pin widget for input */
16760         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16761
16762         { }
16763 };
16764
16765 /*
16766  * 6-stack pin configuration:
16767  */
16768 static struct hda_verb alc861vd_6stack_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         /* Rear Pin: output 1 (0x0d) */
16778         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16779         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16780         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16781         /* CLFE Pin: output 2 (0x0e) */
16782         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16783         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16784         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16785         /* Side Pin: output 3 (0x0f) */
16786         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16787         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16788         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16789
16790         /* Mic (rear) pin: input vref at 80% */
16791         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16792         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16793         /* Front Mic pin: input vref at 80% */
16794         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16795         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16796         /* Line In pin: input */
16797         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16798         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16799         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16800         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16801         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16802         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16803         /* CD pin widget for input */
16804         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16805
16806         { }
16807 };
16808
16809 static struct hda_verb alc861vd_eapd_verbs[] = {
16810         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16811         { }
16812 };
16813
16814 static struct hda_verb alc660vd_eapd_verbs[] = {
16815         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16816         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16817         { }
16818 };
16819
16820 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16821         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16822         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16823         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16824         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16825         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16826         {}
16827 };
16828
16829 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16830 {
16831         struct alc_spec *spec = codec->spec;
16832         spec->autocfg.hp_pins[0] = 0x1b;
16833         spec->autocfg.speaker_pins[0] = 0x14;
16834 }
16835
16836 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16837 {
16838         alc_automute_amp(codec);
16839         alc88x_simple_mic_automute(codec);
16840 }
16841
16842 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16843                                         unsigned int res)
16844 {
16845         switch (res >> 26) {
16846         case ALC880_MIC_EVENT:
16847                 alc88x_simple_mic_automute(codec);
16848                 break;
16849         default:
16850                 alc_automute_amp_unsol_event(codec, res);
16851                 break;
16852         }
16853 }
16854
16855 static struct hda_verb alc861vd_dallas_verbs[] = {
16856         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16857         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16858         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16859         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16860
16861         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16862         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16863         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16864         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16865         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16866         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16867         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16868         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16869
16870         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16871         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16872         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16873         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16874         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16875         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16876         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16877         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16878
16879         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16880         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16881         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16882         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16883         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16884         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16885         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16886         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16887
16888         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16889         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16890         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16891         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16892
16893         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16894         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16895         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16896
16897         { } /* end */
16898 };
16899
16900 /* toggle speaker-output according to the hp-jack state */
16901 static void alc861vd_dallas_setup(struct hda_codec *codec)
16902 {
16903         struct alc_spec *spec = codec->spec;
16904
16905         spec->autocfg.hp_pins[0] = 0x15;
16906         spec->autocfg.speaker_pins[0] = 0x14;
16907 }
16908
16909 #ifdef CONFIG_SND_HDA_POWER_SAVE
16910 #define alc861vd_loopbacks      alc880_loopbacks
16911 #endif
16912
16913 /* pcm configuration: identical with ALC880 */
16914 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16915 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16916 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16917 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16918
16919 /*
16920  * configuration and preset
16921  */
16922 static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = {
16923         [ALC660VD_3ST]          = "3stack-660",
16924         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16925         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16926         [ALC861VD_3ST]          = "3stack",
16927         [ALC861VD_3ST_DIG]      = "3stack-digout",
16928         [ALC861VD_6ST_DIG]      = "6stack-digout",
16929         [ALC861VD_LENOVO]       = "lenovo",
16930         [ALC861VD_DALLAS]       = "dallas",
16931         [ALC861VD_HP]           = "hp",
16932         [ALC861VD_AUTO]         = "auto",
16933 };
16934
16935 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16936         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16937         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16938         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16939         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16940         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16941         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16942         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16943         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16944         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16945         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16946         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16947         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16948         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16949         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16950         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16951         {}
16952 };
16953
16954 static struct alc_config_preset alc861vd_presets[] = {
16955         [ALC660VD_3ST] = {
16956                 .mixers = { alc861vd_3st_mixer },
16957                 .init_verbs = { alc861vd_volume_init_verbs,
16958                                  alc861vd_3stack_init_verbs },
16959                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16960                 .dac_nids = alc660vd_dac_nids,
16961                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16962                 .channel_mode = alc861vd_3stack_2ch_modes,
16963                 .input_mux = &alc861vd_capture_source,
16964         },
16965         [ALC660VD_3ST_DIG] = {
16966                 .mixers = { alc861vd_3st_mixer },
16967                 .init_verbs = { alc861vd_volume_init_verbs,
16968                                  alc861vd_3stack_init_verbs },
16969                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16970                 .dac_nids = alc660vd_dac_nids,
16971                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16972                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16973                 .channel_mode = alc861vd_3stack_2ch_modes,
16974                 .input_mux = &alc861vd_capture_source,
16975         },
16976         [ALC861VD_3ST] = {
16977                 .mixers = { alc861vd_3st_mixer },
16978                 .init_verbs = { alc861vd_volume_init_verbs,
16979                                  alc861vd_3stack_init_verbs },
16980                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16981                 .dac_nids = alc861vd_dac_nids,
16982                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16983                 .channel_mode = alc861vd_3stack_2ch_modes,
16984                 .input_mux = &alc861vd_capture_source,
16985         },
16986         [ALC861VD_3ST_DIG] = {
16987                 .mixers = { alc861vd_3st_mixer },
16988                 .init_verbs = { alc861vd_volume_init_verbs,
16989                                  alc861vd_3stack_init_verbs },
16990                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16991                 .dac_nids = alc861vd_dac_nids,
16992                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16993                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16994                 .channel_mode = alc861vd_3stack_2ch_modes,
16995                 .input_mux = &alc861vd_capture_source,
16996         },
16997         [ALC861VD_6ST_DIG] = {
16998                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16999                 .init_verbs = { alc861vd_volume_init_verbs,
17000                                 alc861vd_6stack_init_verbs },
17001                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17002                 .dac_nids = alc861vd_dac_nids,
17003                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17004                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
17005                 .channel_mode = alc861vd_6stack_modes,
17006                 .input_mux = &alc861vd_capture_source,
17007         },
17008         [ALC861VD_LENOVO] = {
17009                 .mixers = { alc861vd_lenovo_mixer },
17010                 .init_verbs = { alc861vd_volume_init_verbs,
17011                                 alc861vd_3stack_init_verbs,
17012                                 alc861vd_eapd_verbs,
17013                                 alc861vd_lenovo_unsol_verbs },
17014                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17015                 .dac_nids = alc660vd_dac_nids,
17016                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17017                 .channel_mode = alc861vd_3stack_2ch_modes,
17018                 .input_mux = &alc861vd_capture_source,
17019                 .unsol_event = alc861vd_lenovo_unsol_event,
17020                 .setup = alc861vd_lenovo_setup,
17021                 .init_hook = alc861vd_lenovo_init_hook,
17022         },
17023         [ALC861VD_DALLAS] = {
17024                 .mixers = { alc861vd_dallas_mixer },
17025                 .init_verbs = { alc861vd_dallas_verbs },
17026                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17027                 .dac_nids = alc861vd_dac_nids,
17028                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17029                 .channel_mode = alc861vd_3stack_2ch_modes,
17030                 .input_mux = &alc861vd_dallas_capture_source,
17031                 .unsol_event = alc_automute_amp_unsol_event,
17032                 .setup = alc861vd_dallas_setup,
17033                 .init_hook = alc_automute_amp,
17034         },
17035         [ALC861VD_HP] = {
17036                 .mixers = { alc861vd_hp_mixer },
17037                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
17038                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17039                 .dac_nids = alc861vd_dac_nids,
17040                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17041                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17042                 .channel_mode = alc861vd_3stack_2ch_modes,
17043                 .input_mux = &alc861vd_hp_capture_source,
17044                 .unsol_event = alc_automute_amp_unsol_event,
17045                 .setup = alc861vd_dallas_setup,
17046                 .init_hook = alc_automute_amp,
17047         },
17048         [ALC660VD_ASUS_V1S] = {
17049                 .mixers = { alc861vd_lenovo_mixer },
17050                 .init_verbs = { alc861vd_volume_init_verbs,
17051                                 alc861vd_3stack_init_verbs,
17052                                 alc861vd_eapd_verbs,
17053                                 alc861vd_lenovo_unsol_verbs },
17054                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17055                 .dac_nids = alc660vd_dac_nids,
17056                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17057                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17058                 .channel_mode = alc861vd_3stack_2ch_modes,
17059                 .input_mux = &alc861vd_capture_source,
17060                 .unsol_event = alc861vd_lenovo_unsol_event,
17061                 .setup = alc861vd_lenovo_setup,
17062                 .init_hook = alc861vd_lenovo_init_hook,
17063         },
17064 };
17065
17066 /*
17067  * BIOS auto configuration
17068  */
17069 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
17070                                                 const struct auto_pin_cfg *cfg)
17071 {
17072         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
17073 }
17074
17075
17076 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
17077                                 hda_nid_t nid, int pin_type, int dac_idx)
17078 {
17079         alc_set_pin_output(codec, nid, pin_type);
17080 }
17081
17082 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
17083 {
17084         struct alc_spec *spec = codec->spec;
17085         int i;
17086
17087         for (i = 0; i <= HDA_SIDE; i++) {
17088                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17089                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17090                 if (nid)
17091                         alc861vd_auto_set_output_and_unmute(codec, nid,
17092                                                             pin_type, i);
17093         }
17094 }
17095
17096
17097 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17098 {
17099         struct alc_spec *spec = codec->spec;
17100         hda_nid_t pin;
17101
17102         pin = spec->autocfg.hp_pins[0];
17103         if (pin) /* connect to front and use dac 0 */
17104                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17105         pin = spec->autocfg.speaker_pins[0];
17106         if (pin)
17107                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17108 }
17109
17110 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
17111
17112 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17113 {
17114         struct alc_spec *spec = codec->spec;
17115         struct auto_pin_cfg *cfg = &spec->autocfg;
17116         int i;
17117
17118         for (i = 0; i < cfg->num_inputs; i++) {
17119                 hda_nid_t nid = cfg->inputs[i].pin;
17120                 if (alc_is_input_pin(codec, nid)) {
17121                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17122                         if (nid != ALC861VD_PIN_CD_NID &&
17123                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17124                                 snd_hda_codec_write(codec, nid, 0,
17125                                                 AC_VERB_SET_AMP_GAIN_MUTE,
17126                                                 AMP_OUT_MUTE);
17127                 }
17128         }
17129 }
17130
17131 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
17132
17133 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
17134 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
17135
17136 /* add playback controls from the parsed DAC table */
17137 /* Based on ALC880 version. But ALC861VD and ALC887 have separate,
17138  * different NIDs for mute/unmute switch and volume control */
17139 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17140                                              const struct auto_pin_cfg *cfg)
17141 {
17142         static const char * const chname[4] = {
17143                 "Front", "Surround", "CLFE", "Side"
17144         };
17145         const char *pfx = alc_get_line_out_pfx(cfg, true);
17146         hda_nid_t nid_v, nid_s;
17147         int i, err;
17148
17149         for (i = 0; i < cfg->line_outs; i++) {
17150                 if (!spec->multiout.dac_nids[i])
17151                         continue;
17152                 nid_v = alc861vd_idx_to_mixer_vol(
17153                                 alc880_dac_to_idx(
17154                                         spec->multiout.dac_nids[i]));
17155                 nid_s = alc861vd_idx_to_mixer_switch(
17156                                 alc880_dac_to_idx(
17157                                         spec->multiout.dac_nids[i]));
17158
17159                 if (!pfx && i == 2) {
17160                         /* Center/LFE */
17161                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17162                                               "Center",
17163                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17164                                                               HDA_OUTPUT));
17165                         if (err < 0)
17166                                 return err;
17167                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17168                                               "LFE",
17169                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17170                                                               HDA_OUTPUT));
17171                         if (err < 0)
17172                                 return err;
17173                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17174                                              "Center",
17175                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17176                                                               HDA_INPUT));
17177                         if (err < 0)
17178                                 return err;
17179                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17180                                              "LFE",
17181                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17182                                                               HDA_INPUT));
17183                         if (err < 0)
17184                                 return err;
17185                 } else {
17186                         const char *name = pfx;
17187                         if (!name)
17188                                 name = chname[i];
17189                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17190                                                 name, i,
17191                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17192                                                               HDA_OUTPUT));
17193                         if (err < 0)
17194                                 return err;
17195                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17196                                                name, i,
17197                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17198                                                               HDA_INPUT));
17199                         if (err < 0)
17200                                 return err;
17201                 }
17202         }
17203         return 0;
17204 }
17205
17206 /* add playback controls for speaker and HP outputs */
17207 /* Based on ALC880 version. But ALC861VD has separate,
17208  * different NIDs for mute/unmute switch and volume control */
17209 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17210                                         hda_nid_t pin, const char *pfx)
17211 {
17212         hda_nid_t nid_v, nid_s;
17213         int err;
17214
17215         if (!pin)
17216                 return 0;
17217
17218         if (alc880_is_fixed_pin(pin)) {
17219                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17220                 /* specify the DAC as the extra output */
17221                 if (!spec->multiout.hp_nid)
17222                         spec->multiout.hp_nid = nid_v;
17223                 else
17224                         spec->multiout.extra_out_nid[0] = nid_v;
17225                 /* control HP volume/switch on the output mixer amp */
17226                 nid_v = alc861vd_idx_to_mixer_vol(
17227                                 alc880_fixed_pin_idx(pin));
17228                 nid_s = alc861vd_idx_to_mixer_switch(
17229                                 alc880_fixed_pin_idx(pin));
17230
17231                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17232                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17233                 if (err < 0)
17234                         return err;
17235                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17236                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17237                 if (err < 0)
17238                         return err;
17239         } else if (alc880_is_multi_pin(pin)) {
17240                 /* set manual connection */
17241                 /* we have only a switch on HP-out PIN */
17242                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17243                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17244                 if (err < 0)
17245                         return err;
17246         }
17247         return 0;
17248 }
17249
17250 /* parse the BIOS configuration and set up the alc_spec
17251  * return 1 if successful, 0 if the proper config is not found,
17252  * or a negative error code
17253  * Based on ALC880 version - had to change it to override
17254  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17255 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17256 {
17257         struct alc_spec *spec = codec->spec;
17258         int err;
17259         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17260
17261         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17262                                            alc861vd_ignore);
17263         if (err < 0)
17264                 return err;
17265         if (!spec->autocfg.line_outs)
17266                 return 0; /* can't find valid BIOS pin config */
17267
17268         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17269         if (err < 0)
17270                 return err;
17271         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17272         if (err < 0)
17273                 return err;
17274         err = alc861vd_auto_create_extra_out(spec,
17275                                              spec->autocfg.speaker_pins[0],
17276                                              "Speaker");
17277         if (err < 0)
17278                 return err;
17279         err = alc861vd_auto_create_extra_out(spec,
17280                                              spec->autocfg.hp_pins[0],
17281                                              "Headphone");
17282         if (err < 0)
17283                 return err;
17284         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17285         if (err < 0)
17286                 return err;
17287
17288         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17289
17290         alc_auto_parse_digital(codec);
17291
17292         if (spec->kctls.list)
17293                 add_mixer(spec, spec->kctls.list);
17294
17295         add_verb(spec, alc861vd_volume_init_verbs);
17296
17297         spec->num_mux_defs = 1;
17298         spec->input_mux = &spec->private_imux[0];
17299
17300         err = alc_auto_add_mic_boost(codec);
17301         if (err < 0)
17302                 return err;
17303
17304         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17305
17306         return 1;
17307 }
17308
17309 /* additional initialization for auto-configuration model */
17310 static void alc861vd_auto_init(struct hda_codec *codec)
17311 {
17312         struct alc_spec *spec = codec->spec;
17313         alc861vd_auto_init_multi_out(codec);
17314         alc861vd_auto_init_hp_out(codec);
17315         alc861vd_auto_init_analog_input(codec);
17316         alc861vd_auto_init_input_src(codec);
17317         alc_auto_init_digital(codec);
17318         if (spec->unsol_event)
17319                 alc_inithook(codec);
17320 }
17321
17322 enum {
17323         ALC660VD_FIX_ASUS_GPIO1
17324 };
17325
17326 /* reset GPIO1 */
17327 static const struct alc_fixup alc861vd_fixups[] = {
17328         [ALC660VD_FIX_ASUS_GPIO1] = {
17329                 .type = ALC_FIXUP_VERBS,
17330                 .v.verbs = (const struct hda_verb[]) {
17331                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17332                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17333                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17334                         { }
17335                 }
17336         },
17337 };
17338
17339 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17340         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17341         {}
17342 };
17343
17344 static int patch_alc861vd(struct hda_codec *codec)
17345 {
17346         struct alc_spec *spec;
17347         int err, board_config;
17348
17349         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17350         if (spec == NULL)
17351                 return -ENOMEM;
17352
17353         codec->spec = spec;
17354
17355         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17356                                                   alc861vd_models,
17357                                                   alc861vd_cfg_tbl);
17358
17359         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17360                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17361                        codec->chip_name);
17362                 board_config = ALC861VD_AUTO;
17363         }
17364
17365         if (board_config == ALC861VD_AUTO) {
17366                 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
17367                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
17368         }
17369
17370         if (board_config == ALC861VD_AUTO) {
17371                 /* automatic parse from the BIOS config */
17372                 err = alc861vd_parse_auto_config(codec);
17373                 if (err < 0) {
17374                         alc_free(codec);
17375                         return err;
17376                 } else if (!err) {
17377                         printk(KERN_INFO
17378                                "hda_codec: Cannot set up configuration "
17379                                "from BIOS.  Using base mode...\n");
17380                         board_config = ALC861VD_3ST;
17381                 }
17382         }
17383
17384         err = snd_hda_attach_beep_device(codec, 0x23);
17385         if (err < 0) {
17386                 alc_free(codec);
17387                 return err;
17388         }
17389
17390         if (board_config != ALC861VD_AUTO)
17391                 setup_preset(codec, &alc861vd_presets[board_config]);
17392
17393         if (codec->vendor_id == 0x10ec0660) {
17394                 /* always turn on EAPD */
17395                 add_verb(spec, alc660vd_eapd_verbs);
17396         }
17397
17398         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17399         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17400
17401         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17402         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17403
17404         if (!spec->adc_nids) {
17405                 spec->adc_nids = alc861vd_adc_nids;
17406                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17407         }
17408         if (!spec->capsrc_nids)
17409                 spec->capsrc_nids = alc861vd_capsrc_nids;
17410
17411         set_capture_mixer(codec);
17412         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17413
17414         spec->vmaster_nid = 0x02;
17415
17416         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
17417
17418         codec->patch_ops = alc_patch_ops;
17419
17420         if (board_config == ALC861VD_AUTO)
17421                 spec->init_hook = alc861vd_auto_init;
17422 #ifdef CONFIG_SND_HDA_POWER_SAVE
17423         if (!spec->loopback.amplist)
17424                 spec->loopback.amplist = alc861vd_loopbacks;
17425 #endif
17426
17427         return 0;
17428 }
17429
17430 /*
17431  * ALC662 support
17432  *
17433  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17434  * configuration.  Each pin widget can choose any input DACs and a mixer.
17435  * Each ADC is connected from a mixer of all inputs.  This makes possible
17436  * 6-channel independent captures.
17437  *
17438  * In addition, an independent DAC for the multi-playback (not used in this
17439  * driver yet).
17440  */
17441 #define ALC662_DIGOUT_NID       0x06
17442 #define ALC662_DIGIN_NID        0x0a
17443
17444 static hda_nid_t alc662_dac_nids[4] = {
17445         /* front, rear, clfe, rear_surr */
17446         0x02, 0x03, 0x04
17447 };
17448
17449 static hda_nid_t alc272_dac_nids[2] = {
17450         0x02, 0x03
17451 };
17452
17453 static hda_nid_t alc662_adc_nids[2] = {
17454         /* ADC1-2 */
17455         0x09, 0x08
17456 };
17457
17458 static hda_nid_t alc272_adc_nids[1] = {
17459         /* ADC1-2 */
17460         0x08,
17461 };
17462
17463 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17464 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17465
17466
17467 /* input MUX */
17468 /* FIXME: should be a matrix-type input source selection */
17469 static struct hda_input_mux alc662_capture_source = {
17470         .num_items = 4,
17471         .items = {
17472                 { "Mic", 0x0 },
17473                 { "Front Mic", 0x1 },
17474                 { "Line", 0x2 },
17475                 { "CD", 0x4 },
17476         },
17477 };
17478
17479 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17480         .num_items = 2,
17481         .items = {
17482                 { "Mic", 0x1 },
17483                 { "Line", 0x2 },
17484         },
17485 };
17486
17487 static struct hda_input_mux alc663_capture_source = {
17488         .num_items = 3,
17489         .items = {
17490                 { "Mic", 0x0 },
17491                 { "Front Mic", 0x1 },
17492                 { "Line", 0x2 },
17493         },
17494 };
17495
17496 #if 0 /* set to 1 for testing other input sources below */
17497 static struct hda_input_mux alc272_nc10_capture_source = {
17498         .num_items = 16,
17499         .items = {
17500                 { "Autoselect Mic", 0x0 },
17501                 { "Internal Mic", 0x1 },
17502                 { "In-0x02", 0x2 },
17503                 { "In-0x03", 0x3 },
17504                 { "In-0x04", 0x4 },
17505                 { "In-0x05", 0x5 },
17506                 { "In-0x06", 0x6 },
17507                 { "In-0x07", 0x7 },
17508                 { "In-0x08", 0x8 },
17509                 { "In-0x09", 0x9 },
17510                 { "In-0x0a", 0x0a },
17511                 { "In-0x0b", 0x0b },
17512                 { "In-0x0c", 0x0c },
17513                 { "In-0x0d", 0x0d },
17514                 { "In-0x0e", 0x0e },
17515                 { "In-0x0f", 0x0f },
17516         },
17517 };
17518 #endif
17519
17520 /*
17521  * 2ch mode
17522  */
17523 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17524         { 2, NULL }
17525 };
17526
17527 /*
17528  * 2ch mode
17529  */
17530 static struct hda_verb alc662_3ST_ch2_init[] = {
17531         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17532         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17533         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17534         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17535         { } /* end */
17536 };
17537
17538 /*
17539  * 6ch mode
17540  */
17541 static struct hda_verb alc662_3ST_ch6_init[] = {
17542         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17543         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17544         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17545         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17546         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17547         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17548         { } /* end */
17549 };
17550
17551 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17552         { 2, alc662_3ST_ch2_init },
17553         { 6, alc662_3ST_ch6_init },
17554 };
17555
17556 /*
17557  * 2ch mode
17558  */
17559 static struct hda_verb alc662_sixstack_ch6_init[] = {
17560         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17561         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17562         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17563         { } /* end */
17564 };
17565
17566 /*
17567  * 6ch mode
17568  */
17569 static struct hda_verb alc662_sixstack_ch8_init[] = {
17570         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17571         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17572         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17573         { } /* end */
17574 };
17575
17576 static struct hda_channel_mode alc662_5stack_modes[2] = {
17577         { 2, alc662_sixstack_ch6_init },
17578         { 6, alc662_sixstack_ch8_init },
17579 };
17580
17581 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17582  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17583  */
17584
17585 static struct snd_kcontrol_new alc662_base_mixer[] = {
17586         /* output mixer control */
17587         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17588         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17589         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17590         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17591         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17592         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17593         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17594         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17595         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17596
17597         /*Input mixer control */
17598         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17599         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17600         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17601         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17602         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17603         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17604         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17605         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17606         { } /* end */
17607 };
17608
17609 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17610         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17611         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17612         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17613         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17614         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17615         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17616         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17617         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17618         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17619         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17620         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17621         { } /* end */
17622 };
17623
17624 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17625         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17626         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17627         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17628         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17629         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17630         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17631         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17632         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17633         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17634         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17635         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17636         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17637         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17638         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17639         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17640         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17641         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17642         { } /* end */
17643 };
17644
17645 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17646         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17647         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17648         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17649         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17650         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17651         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17652         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17653         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17654         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17655         { } /* end */
17656 };
17657
17658 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17659         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17660         ALC262_HIPPO_MASTER_SWITCH,
17661
17662         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
17663         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17664         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17665
17666         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
17667         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17668         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17669         { } /* end */
17670 };
17671
17672 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17673         ALC262_HIPPO_MASTER_SWITCH,
17674         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17675         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17676         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17677         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17678         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17679         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17680         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17681         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17682         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17683         { } /* end */
17684 };
17685
17686 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17687         .ops = &snd_hda_bind_vol,
17688         .values = {
17689                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17690                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17691                 0
17692         },
17693 };
17694
17695 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17696         .ops = &snd_hda_bind_sw,
17697         .values = {
17698                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17699                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17700                 0
17701         },
17702 };
17703
17704 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17705         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17706         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17707         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17708         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17709         { } /* end */
17710 };
17711
17712 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17713         .ops = &snd_hda_bind_sw,
17714         .values = {
17715                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17716                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17717                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17718                 0
17719         },
17720 };
17721
17722 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17723         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17724         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17725         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17726         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17727         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17728         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17729
17730         { } /* end */
17731 };
17732
17733 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17734         .ops = &snd_hda_bind_sw,
17735         .values = {
17736                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17737                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17738                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17739                 0
17740         },
17741 };
17742
17743 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17744         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17745         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_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         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17749         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17750         { } /* end */
17751 };
17752
17753 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17754         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17755         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17756         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17757         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17758         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17759         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17760         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17761         { } /* end */
17762 };
17763
17764 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17765         .ops = &snd_hda_bind_vol,
17766         .values = {
17767                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17768                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17769                 0
17770         },
17771 };
17772
17773 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17774         .ops = &snd_hda_bind_sw,
17775         .values = {
17776                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17777                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17778                 0
17779         },
17780 };
17781
17782 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17783         HDA_BIND_VOL("Master Playback Volume",
17784                                 &alc663_asus_two_bind_master_vol),
17785         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17786         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17787         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17788         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17789         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17790         { } /* end */
17791 };
17792
17793 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17794         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17795         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17796         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17797         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17798         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17799         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17800         { } /* end */
17801 };
17802
17803 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17804         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17805         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17806         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17807         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17808         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17809
17810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17811         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17812         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17813         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17814         { } /* end */
17815 };
17816
17817 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17818         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17819         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17820         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17821
17822         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17823         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17824         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17825         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17826         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17827         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17828         { } /* end */
17829 };
17830
17831 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17832         .ops = &snd_hda_bind_sw,
17833         .values = {
17834                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17835                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17836                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17837                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17838                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17839                 0
17840         },
17841 };
17842
17843 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17844         .ops = &snd_hda_bind_sw,
17845         .values = {
17846                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17847                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17848                 0
17849         },
17850 };
17851
17852 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17853         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17854         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17855         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17856         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17857         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17858         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17859         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17860         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17861         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17862         { } /* end */
17863 };
17864
17865 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17866         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17867         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17868         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17869         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17870         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17871         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17872         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17873         { } /* end */
17874 };
17875
17876
17877 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17878         {
17879                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17880                 .name = "Channel Mode",
17881                 .info = alc_ch_mode_info,
17882                 .get = alc_ch_mode_get,
17883                 .put = alc_ch_mode_put,
17884         },
17885         { } /* end */
17886 };
17887
17888 static struct hda_verb alc662_init_verbs[] = {
17889         /* ADC: mute amp left and right */
17890         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17891         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17892
17893         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17894         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17895         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17896         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17897         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17898         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17899
17900         /* Front Pin: output 0 (0x0c) */
17901         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17902         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17903
17904         /* Rear Pin: output 1 (0x0d) */
17905         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17906         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17907
17908         /* CLFE Pin: output 2 (0x0e) */
17909         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17910         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17911
17912         /* Mic (rear) pin: input vref at 80% */
17913         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17914         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17915         /* Front Mic pin: input vref at 80% */
17916         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17917         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17918         /* Line In pin: input */
17919         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17920         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17921         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17922         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17923         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17924         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17925         /* CD pin widget for input */
17926         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17927
17928         /* FIXME: use matrix-type input source selection */
17929         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17930         /* Input mixer */
17931         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17932         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17933
17934         /* always trun on EAPD */
17935         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17936         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17937
17938         { }
17939 };
17940
17941 static struct hda_verb alc663_init_verbs[] = {
17942         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17943         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17944         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17945         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17946         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17947         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17948         { }
17949 };
17950
17951 static struct hda_verb alc272_init_verbs[] = {
17952         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17953         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17954         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17955         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17956         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17957         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17958         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17959         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17960         { }
17961 };
17962
17963 static struct hda_verb alc662_sue_init_verbs[] = {
17964         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17965         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17966         {}
17967 };
17968
17969 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17970         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17971         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17972         {}
17973 };
17974
17975 /* Set Unsolicited Event*/
17976 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17977         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17978         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17979         {}
17980 };
17981
17982 static struct hda_verb alc663_m51va_init_verbs[] = {
17983         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17984         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17985         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17986         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17987         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17988         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17989         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17990         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17991         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17992         {}
17993 };
17994
17995 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17996         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17997         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17998         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17999         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18000         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18001         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18002         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18003         {}
18004 };
18005
18006 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
18007         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18008         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18009         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18010         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18011         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18012         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18013         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18014         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18015         {}
18016 };
18017
18018 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
18019         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18020         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18021         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18022         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18023         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18024         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18025         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18026         {}
18027 };
18028
18029 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
18030         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18031         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18032         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18033         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18034         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18035         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18036         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18037         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18038         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18039         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18040         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18041         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18042         {}
18043 };
18044
18045 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
18046         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18047         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18048         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18049         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18050         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18051         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18052         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18053         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18054         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18055         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18056         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18057         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18058         {}
18059 };
18060
18061 static struct hda_verb alc663_g71v_init_verbs[] = {
18062         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18063         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
18064         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
18065
18066         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18067         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18068         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18069
18070         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
18071         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
18072         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
18073         {}
18074 };
18075
18076 static struct hda_verb alc663_g50v_init_verbs[] = {
18077         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18078         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18079         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18080
18081         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18082         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18083         {}
18084 };
18085
18086 static struct hda_verb alc662_ecs_init_verbs[] = {
18087         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
18088         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18089         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18090         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18091         {}
18092 };
18093
18094 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
18095         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18096         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18097         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18098         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18099         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18100         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18101         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18102         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18103         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18104         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18105         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18106         {}
18107 };
18108
18109 static struct hda_verb alc272_dell_init_verbs[] = {
18110         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18111         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18112         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18113         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18114         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18115         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18116         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18117         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18118         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18119         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18120         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18121         {}
18122 };
18123
18124 static struct hda_verb alc663_mode7_init_verbs[] = {
18125         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18126         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18127         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18128         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18129         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18130         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18131         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18132         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18133         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18134         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18135         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18136         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18137         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18138         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18139         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18140         {}
18141 };
18142
18143 static struct hda_verb alc663_mode8_init_verbs[] = {
18144         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18145         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18146         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18147         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18148         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18149         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18150         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18151         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
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         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18158         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18159         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18160         {}
18161 };
18162
18163 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18164         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18165         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18166         { } /* end */
18167 };
18168
18169 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18170         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18171         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18172         { } /* end */
18173 };
18174
18175 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
18176 {
18177         unsigned int present;
18178         unsigned char bits;
18179
18180         present = snd_hda_jack_detect(codec, 0x14);
18181         bits = present ? HDA_AMP_MUTE : 0;
18182
18183         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18184                                  HDA_AMP_MUTE, bits);
18185 }
18186
18187 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
18188 {
18189         unsigned int present;
18190         unsigned char bits;
18191
18192         present = snd_hda_jack_detect(codec, 0x1b);
18193         bits = present ? HDA_AMP_MUTE : 0;
18194
18195         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18196                                  HDA_AMP_MUTE, bits);
18197         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18198                                  HDA_AMP_MUTE, bits);
18199 }
18200
18201 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
18202                                            unsigned int res)
18203 {
18204         if ((res >> 26) == ALC880_HP_EVENT)
18205                 alc662_lenovo_101e_all_automute(codec);
18206         if ((res >> 26) == ALC880_FRONT_EVENT)
18207                 alc662_lenovo_101e_ispeaker_automute(codec);
18208 }
18209
18210 /* unsolicited event for HP jack sensing */
18211 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
18212                                      unsigned int res)
18213 {
18214         if ((res >> 26) == ALC880_MIC_EVENT)
18215                 alc_mic_automute(codec);
18216         else
18217                 alc262_hippo_unsol_event(codec, res);
18218 }
18219
18220 static void alc662_eeepc_setup(struct hda_codec *codec)
18221 {
18222         struct alc_spec *spec = codec->spec;
18223
18224         alc262_hippo1_setup(codec);
18225         spec->ext_mic.pin = 0x18;
18226         spec->ext_mic.mux_idx = 0;
18227         spec->int_mic.pin = 0x19;
18228         spec->int_mic.mux_idx = 1;
18229         spec->auto_mic = 1;
18230 }
18231
18232 static void alc662_eeepc_inithook(struct hda_codec *codec)
18233 {
18234         alc262_hippo_automute(codec);
18235         alc_mic_automute(codec);
18236 }
18237
18238 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18239 {
18240         struct alc_spec *spec = codec->spec;
18241
18242         spec->autocfg.hp_pins[0] = 0x14;
18243         spec->autocfg.speaker_pins[0] = 0x1b;
18244 }
18245
18246 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
18247
18248 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18249 {
18250         unsigned int present;
18251         unsigned char bits;
18252
18253         present = snd_hda_jack_detect(codec, 0x21);
18254         bits = present ? HDA_AMP_MUTE : 0;
18255         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18256                                  HDA_AMP_MUTE, bits);
18257         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18258                                  HDA_AMP_MUTE, bits);
18259 }
18260
18261 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18262 {
18263         unsigned int present;
18264         unsigned char bits;
18265
18266         present = snd_hda_jack_detect(codec, 0x21);
18267         bits = present ? HDA_AMP_MUTE : 0;
18268         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18269                                  HDA_AMP_MUTE, bits);
18270         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18271                                  HDA_AMP_MUTE, bits);
18272         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18273                                  HDA_AMP_MUTE, bits);
18274         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18275                                  HDA_AMP_MUTE, bits);
18276 }
18277
18278 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18279 {
18280         unsigned int present;
18281         unsigned char bits;
18282
18283         present = snd_hda_jack_detect(codec, 0x15);
18284         bits = present ? HDA_AMP_MUTE : 0;
18285         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18286                                  HDA_AMP_MUTE, bits);
18287         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18288                                  HDA_AMP_MUTE, bits);
18289         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18290                                  HDA_AMP_MUTE, bits);
18291         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18292                                  HDA_AMP_MUTE, bits);
18293 }
18294
18295 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18296 {
18297         unsigned int present;
18298         unsigned char bits;
18299
18300         present = snd_hda_jack_detect(codec, 0x1b);
18301         bits = present ? 0 : PIN_OUT;
18302         snd_hda_codec_write(codec, 0x14, 0,
18303                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18304 }
18305
18306 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18307 {
18308         unsigned int present1, present2;
18309
18310         present1 = snd_hda_jack_detect(codec, 0x21);
18311         present2 = snd_hda_jack_detect(codec, 0x15);
18312
18313         if (present1 || present2) {
18314                 snd_hda_codec_write_cache(codec, 0x14, 0,
18315                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18316         } else {
18317                 snd_hda_codec_write_cache(codec, 0x14, 0,
18318                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18319         }
18320 }
18321
18322 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18323 {
18324         unsigned int present1, present2;
18325
18326         present1 = snd_hda_jack_detect(codec, 0x1b);
18327         present2 = snd_hda_jack_detect(codec, 0x15);
18328
18329         if (present1 || present2) {
18330                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18331                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18332                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18333                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18334         } else {
18335                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18336                                          HDA_AMP_MUTE, 0);
18337                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18338                                          HDA_AMP_MUTE, 0);
18339         }
18340 }
18341
18342 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18343 {
18344         unsigned int present1, present2;
18345
18346         present1 = snd_hda_codec_read(codec, 0x1b, 0,
18347                         AC_VERB_GET_PIN_SENSE, 0)
18348                         & AC_PINSENSE_PRESENCE;
18349         present2 = snd_hda_codec_read(codec, 0x21, 0,
18350                         AC_VERB_GET_PIN_SENSE, 0)
18351                         & AC_PINSENSE_PRESENCE;
18352
18353         if (present1 || present2) {
18354                 snd_hda_codec_write_cache(codec, 0x14, 0,
18355                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18356                 snd_hda_codec_write_cache(codec, 0x17, 0,
18357                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18358         } else {
18359                 snd_hda_codec_write_cache(codec, 0x14, 0,
18360                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18361                 snd_hda_codec_write_cache(codec, 0x17, 0,
18362                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18363         }
18364 }
18365
18366 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18367 {
18368         unsigned int present1, present2;
18369
18370         present1 = snd_hda_codec_read(codec, 0x21, 0,
18371                         AC_VERB_GET_PIN_SENSE, 0)
18372                         & AC_PINSENSE_PRESENCE;
18373         present2 = snd_hda_codec_read(codec, 0x15, 0,
18374                         AC_VERB_GET_PIN_SENSE, 0)
18375                         & AC_PINSENSE_PRESENCE;
18376
18377         if (present1 || present2) {
18378                 snd_hda_codec_write_cache(codec, 0x14, 0,
18379                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18380                 snd_hda_codec_write_cache(codec, 0x17, 0,
18381                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18382         } else {
18383                 snd_hda_codec_write_cache(codec, 0x14, 0,
18384                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18385                 snd_hda_codec_write_cache(codec, 0x17, 0,
18386                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18387         }
18388 }
18389
18390 static void alc663_m51va_unsol_event(struct hda_codec *codec,
18391                                            unsigned int res)
18392 {
18393         switch (res >> 26) {
18394         case ALC880_HP_EVENT:
18395                 alc663_m51va_speaker_automute(codec);
18396                 break;
18397         case ALC880_MIC_EVENT:
18398                 alc_mic_automute(codec);
18399                 break;
18400         }
18401 }
18402
18403 static void alc663_m51va_setup(struct hda_codec *codec)
18404 {
18405         struct alc_spec *spec = codec->spec;
18406         spec->ext_mic.pin = 0x18;
18407         spec->ext_mic.mux_idx = 0;
18408         spec->int_mic.pin = 0x12;
18409         spec->int_mic.mux_idx = 9;
18410         spec->auto_mic = 1;
18411 }
18412
18413 static void alc663_m51va_inithook(struct hda_codec *codec)
18414 {
18415         alc663_m51va_speaker_automute(codec);
18416         alc_mic_automute(codec);
18417 }
18418
18419 /* ***************** Mode1 ******************************/
18420 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
18421
18422 static void alc663_mode1_setup(struct hda_codec *codec)
18423 {
18424         struct alc_spec *spec = codec->spec;
18425         spec->ext_mic.pin = 0x18;
18426         spec->ext_mic.mux_idx = 0;
18427         spec->int_mic.pin = 0x19;
18428         spec->int_mic.mux_idx = 1;
18429         spec->auto_mic = 1;
18430 }
18431
18432 #define alc663_mode1_inithook           alc663_m51va_inithook
18433
18434 /* ***************** Mode2 ******************************/
18435 static void alc662_mode2_unsol_event(struct hda_codec *codec,
18436                                            unsigned int res)
18437 {
18438         switch (res >> 26) {
18439         case ALC880_HP_EVENT:
18440                 alc662_f5z_speaker_automute(codec);
18441                 break;
18442         case ALC880_MIC_EVENT:
18443                 alc_mic_automute(codec);
18444                 break;
18445         }
18446 }
18447
18448 #define alc662_mode2_setup      alc663_mode1_setup
18449
18450 static void alc662_mode2_inithook(struct hda_codec *codec)
18451 {
18452         alc662_f5z_speaker_automute(codec);
18453         alc_mic_automute(codec);
18454 }
18455 /* ***************** Mode3 ******************************/
18456 static void alc663_mode3_unsol_event(struct hda_codec *codec,
18457                                            unsigned int res)
18458 {
18459         switch (res >> 26) {
18460         case ALC880_HP_EVENT:
18461                 alc663_two_hp_m1_speaker_automute(codec);
18462                 break;
18463         case ALC880_MIC_EVENT:
18464                 alc_mic_automute(codec);
18465                 break;
18466         }
18467 }
18468
18469 #define alc663_mode3_setup      alc663_mode1_setup
18470
18471 static void alc663_mode3_inithook(struct hda_codec *codec)
18472 {
18473         alc663_two_hp_m1_speaker_automute(codec);
18474         alc_mic_automute(codec);
18475 }
18476 /* ***************** Mode4 ******************************/
18477 static void alc663_mode4_unsol_event(struct hda_codec *codec,
18478                                            unsigned int res)
18479 {
18480         switch (res >> 26) {
18481         case ALC880_HP_EVENT:
18482                 alc663_21jd_two_speaker_automute(codec);
18483                 break;
18484         case ALC880_MIC_EVENT:
18485                 alc_mic_automute(codec);
18486                 break;
18487         }
18488 }
18489
18490 #define alc663_mode4_setup      alc663_mode1_setup
18491
18492 static void alc663_mode4_inithook(struct hda_codec *codec)
18493 {
18494         alc663_21jd_two_speaker_automute(codec);
18495         alc_mic_automute(codec);
18496 }
18497 /* ***************** Mode5 ******************************/
18498 static void alc663_mode5_unsol_event(struct hda_codec *codec,
18499                                            unsigned int res)
18500 {
18501         switch (res >> 26) {
18502         case ALC880_HP_EVENT:
18503                 alc663_15jd_two_speaker_automute(codec);
18504                 break;
18505         case ALC880_MIC_EVENT:
18506                 alc_mic_automute(codec);
18507                 break;
18508         }
18509 }
18510
18511 #define alc663_mode5_setup      alc663_mode1_setup
18512
18513 static void alc663_mode5_inithook(struct hda_codec *codec)
18514 {
18515         alc663_15jd_two_speaker_automute(codec);
18516         alc_mic_automute(codec);
18517 }
18518 /* ***************** Mode6 ******************************/
18519 static void alc663_mode6_unsol_event(struct hda_codec *codec,
18520                                            unsigned int res)
18521 {
18522         switch (res >> 26) {
18523         case ALC880_HP_EVENT:
18524                 alc663_two_hp_m2_speaker_automute(codec);
18525                 break;
18526         case ALC880_MIC_EVENT:
18527                 alc_mic_automute(codec);
18528                 break;
18529         }
18530 }
18531
18532 #define alc663_mode6_setup      alc663_mode1_setup
18533
18534 static void alc663_mode6_inithook(struct hda_codec *codec)
18535 {
18536         alc663_two_hp_m2_speaker_automute(codec);
18537         alc_mic_automute(codec);
18538 }
18539
18540 /* ***************** Mode7 ******************************/
18541 static void alc663_mode7_unsol_event(struct hda_codec *codec,
18542                                            unsigned int res)
18543 {
18544         switch (res >> 26) {
18545         case ALC880_HP_EVENT:
18546                 alc663_two_hp_m7_speaker_automute(codec);
18547                 break;
18548         case ALC880_MIC_EVENT:
18549                 alc_mic_automute(codec);
18550                 break;
18551         }
18552 }
18553
18554 #define alc663_mode7_setup      alc663_mode1_setup
18555
18556 static void alc663_mode7_inithook(struct hda_codec *codec)
18557 {
18558         alc663_two_hp_m7_speaker_automute(codec);
18559         alc_mic_automute(codec);
18560 }
18561
18562 /* ***************** Mode8 ******************************/
18563 static void alc663_mode8_unsol_event(struct hda_codec *codec,
18564                                            unsigned int res)
18565 {
18566         switch (res >> 26) {
18567         case ALC880_HP_EVENT:
18568                 alc663_two_hp_m8_speaker_automute(codec);
18569                 break;
18570         case ALC880_MIC_EVENT:
18571                 alc_mic_automute(codec);
18572                 break;
18573         }
18574 }
18575
18576 #define alc663_mode8_setup      alc663_m51va_setup
18577
18578 static void alc663_mode8_inithook(struct hda_codec *codec)
18579 {
18580         alc663_two_hp_m8_speaker_automute(codec);
18581         alc_mic_automute(codec);
18582 }
18583
18584 static void alc663_g71v_hp_automute(struct hda_codec *codec)
18585 {
18586         unsigned int present;
18587         unsigned char bits;
18588
18589         present = snd_hda_jack_detect(codec, 0x21);
18590         bits = present ? HDA_AMP_MUTE : 0;
18591         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18592                                  HDA_AMP_MUTE, bits);
18593         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18594                                  HDA_AMP_MUTE, bits);
18595 }
18596
18597 static void alc663_g71v_front_automute(struct hda_codec *codec)
18598 {
18599         unsigned int present;
18600         unsigned char bits;
18601
18602         present = snd_hda_jack_detect(codec, 0x15);
18603         bits = present ? HDA_AMP_MUTE : 0;
18604         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18605                                  HDA_AMP_MUTE, bits);
18606 }
18607
18608 static void alc663_g71v_unsol_event(struct hda_codec *codec,
18609                                            unsigned int res)
18610 {
18611         switch (res >> 26) {
18612         case ALC880_HP_EVENT:
18613                 alc663_g71v_hp_automute(codec);
18614                 break;
18615         case ALC880_FRONT_EVENT:
18616                 alc663_g71v_front_automute(codec);
18617                 break;
18618         case ALC880_MIC_EVENT:
18619                 alc_mic_automute(codec);
18620                 break;
18621         }
18622 }
18623
18624 #define alc663_g71v_setup       alc663_m51va_setup
18625
18626 static void alc663_g71v_inithook(struct hda_codec *codec)
18627 {
18628         alc663_g71v_front_automute(codec);
18629         alc663_g71v_hp_automute(codec);
18630         alc_mic_automute(codec);
18631 }
18632
18633 static void alc663_g50v_unsol_event(struct hda_codec *codec,
18634                                            unsigned int res)
18635 {
18636         switch (res >> 26) {
18637         case ALC880_HP_EVENT:
18638                 alc663_m51va_speaker_automute(codec);
18639                 break;
18640         case ALC880_MIC_EVENT:
18641                 alc_mic_automute(codec);
18642                 break;
18643         }
18644 }
18645
18646 #define alc663_g50v_setup       alc663_m51va_setup
18647
18648 static void alc663_g50v_inithook(struct hda_codec *codec)
18649 {
18650         alc663_m51va_speaker_automute(codec);
18651         alc_mic_automute(codec);
18652 }
18653
18654 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18655         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18656         ALC262_HIPPO_MASTER_SWITCH,
18657
18658         HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT),
18659         HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18660         HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18661
18662         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18663         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18664         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18665         { } /* end */
18666 };
18667
18668 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18669         /* Master Playback automatically created from Speaker and Headphone */
18670         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18671         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18672         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18673         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18674
18675         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18676         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18677         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
18678
18679         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18680         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18681         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18682         { } /* end */
18683 };
18684
18685 #ifdef CONFIG_SND_HDA_POWER_SAVE
18686 #define alc662_loopbacks        alc880_loopbacks
18687 #endif
18688
18689
18690 /* pcm configuration: identical with ALC880 */
18691 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18692 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18693 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18694 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18695
18696 /*
18697  * configuration and preset
18698  */
18699 static const char * const alc662_models[ALC662_MODEL_LAST] = {
18700         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18701         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18702         [ALC662_3ST_6ch]        = "3stack-6ch",
18703         [ALC662_5ST_DIG]        = "6stack-dig",
18704         [ALC662_LENOVO_101E]    = "lenovo-101e",
18705         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18706         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18707         [ALC662_ECS] = "ecs",
18708         [ALC663_ASUS_M51VA] = "m51va",
18709         [ALC663_ASUS_G71V] = "g71v",
18710         [ALC663_ASUS_H13] = "h13",
18711         [ALC663_ASUS_G50V] = "g50v",
18712         [ALC663_ASUS_MODE1] = "asus-mode1",
18713         [ALC662_ASUS_MODE2] = "asus-mode2",
18714         [ALC663_ASUS_MODE3] = "asus-mode3",
18715         [ALC663_ASUS_MODE4] = "asus-mode4",
18716         [ALC663_ASUS_MODE5] = "asus-mode5",
18717         [ALC663_ASUS_MODE6] = "asus-mode6",
18718         [ALC663_ASUS_MODE7] = "asus-mode7",
18719         [ALC663_ASUS_MODE8] = "asus-mode8",
18720         [ALC272_DELL]           = "dell",
18721         [ALC272_DELL_ZM1]       = "dell-zm1",
18722         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18723         [ALC662_AUTO]           = "auto",
18724 };
18725
18726 static struct snd_pci_quirk alc662_cfg_tbl[] = {
18727         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18728         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18729         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18730         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18731         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18732         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18733         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18734         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18735         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18736         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18737         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18738         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18739         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18740         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18741         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18742         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18743         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18744         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18745         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18746         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18747         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18748         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18749         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18750         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18751         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18752         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18753         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18754         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18755         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18756         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18757         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18758         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18759         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18760         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18761         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18762         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18763         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18764         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18765         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18766         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18767         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18768         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18769         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18770         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18771         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18772         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18773         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18774         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18775         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18776         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18777         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18778         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18779         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18780         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18781         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18782         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18783         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18784         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18785         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18786         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18787         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18788         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18789         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18790         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18791                       ALC662_3ST_6ch_DIG),
18792         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18793         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18794         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18795                       ALC662_3ST_6ch_DIG),
18796         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18797         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18798         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18799         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18800         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18801                                         ALC662_3ST_6ch_DIG),
18802         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18803                            ALC663_ASUS_H13),
18804         {}
18805 };
18806
18807 static struct alc_config_preset alc662_presets[] = {
18808         [ALC662_3ST_2ch_DIG] = {
18809                 .mixers = { alc662_3ST_2ch_mixer },
18810                 .init_verbs = { alc662_init_verbs },
18811                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18812                 .dac_nids = alc662_dac_nids,
18813                 .dig_out_nid = ALC662_DIGOUT_NID,
18814                 .dig_in_nid = ALC662_DIGIN_NID,
18815                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18816                 .channel_mode = alc662_3ST_2ch_modes,
18817                 .input_mux = &alc662_capture_source,
18818         },
18819         [ALC662_3ST_6ch_DIG] = {
18820                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18821                 .init_verbs = { alc662_init_verbs },
18822                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18823                 .dac_nids = alc662_dac_nids,
18824                 .dig_out_nid = ALC662_DIGOUT_NID,
18825                 .dig_in_nid = ALC662_DIGIN_NID,
18826                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18827                 .channel_mode = alc662_3ST_6ch_modes,
18828                 .need_dac_fix = 1,
18829                 .input_mux = &alc662_capture_source,
18830         },
18831         [ALC662_3ST_6ch] = {
18832                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18833                 .init_verbs = { alc662_init_verbs },
18834                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18835                 .dac_nids = alc662_dac_nids,
18836                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18837                 .channel_mode = alc662_3ST_6ch_modes,
18838                 .need_dac_fix = 1,
18839                 .input_mux = &alc662_capture_source,
18840         },
18841         [ALC662_5ST_DIG] = {
18842                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18843                 .init_verbs = { alc662_init_verbs },
18844                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18845                 .dac_nids = alc662_dac_nids,
18846                 .dig_out_nid = ALC662_DIGOUT_NID,
18847                 .dig_in_nid = ALC662_DIGIN_NID,
18848                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18849                 .channel_mode = alc662_5stack_modes,
18850                 .input_mux = &alc662_capture_source,
18851         },
18852         [ALC662_LENOVO_101E] = {
18853                 .mixers = { alc662_lenovo_101e_mixer },
18854                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18855                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18856                 .dac_nids = alc662_dac_nids,
18857                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18858                 .channel_mode = alc662_3ST_2ch_modes,
18859                 .input_mux = &alc662_lenovo_101e_capture_source,
18860                 .unsol_event = alc662_lenovo_101e_unsol_event,
18861                 .init_hook = alc662_lenovo_101e_all_automute,
18862         },
18863         [ALC662_ASUS_EEEPC_P701] = {
18864                 .mixers = { alc662_eeepc_p701_mixer },
18865                 .init_verbs = { alc662_init_verbs,
18866                                 alc662_eeepc_sue_init_verbs },
18867                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18868                 .dac_nids = alc662_dac_nids,
18869                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18870                 .channel_mode = alc662_3ST_2ch_modes,
18871                 .unsol_event = alc662_eeepc_unsol_event,
18872                 .setup = alc662_eeepc_setup,
18873                 .init_hook = alc662_eeepc_inithook,
18874         },
18875         [ALC662_ASUS_EEEPC_EP20] = {
18876                 .mixers = { alc662_eeepc_ep20_mixer,
18877                             alc662_chmode_mixer },
18878                 .init_verbs = { alc662_init_verbs,
18879                                 alc662_eeepc_ep20_sue_init_verbs },
18880                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18881                 .dac_nids = alc662_dac_nids,
18882                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18883                 .channel_mode = alc662_3ST_6ch_modes,
18884                 .input_mux = &alc662_lenovo_101e_capture_source,
18885                 .unsol_event = alc662_eeepc_unsol_event,
18886                 .setup = alc662_eeepc_ep20_setup,
18887                 .init_hook = alc662_eeepc_ep20_inithook,
18888         },
18889         [ALC662_ECS] = {
18890                 .mixers = { alc662_ecs_mixer },
18891                 .init_verbs = { alc662_init_verbs,
18892                                 alc662_ecs_init_verbs },
18893                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18894                 .dac_nids = alc662_dac_nids,
18895                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18896                 .channel_mode = alc662_3ST_2ch_modes,
18897                 .unsol_event = alc662_eeepc_unsol_event,
18898                 .setup = alc662_eeepc_setup,
18899                 .init_hook = alc662_eeepc_inithook,
18900         },
18901         [ALC663_ASUS_M51VA] = {
18902                 .mixers = { alc663_m51va_mixer },
18903                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18904                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18905                 .dac_nids = alc662_dac_nids,
18906                 .dig_out_nid = ALC662_DIGOUT_NID,
18907                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18908                 .channel_mode = alc662_3ST_2ch_modes,
18909                 .unsol_event = alc663_m51va_unsol_event,
18910                 .setup = alc663_m51va_setup,
18911                 .init_hook = alc663_m51va_inithook,
18912         },
18913         [ALC663_ASUS_G71V] = {
18914                 .mixers = { alc663_g71v_mixer },
18915                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18916                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18917                 .dac_nids = alc662_dac_nids,
18918                 .dig_out_nid = ALC662_DIGOUT_NID,
18919                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18920                 .channel_mode = alc662_3ST_2ch_modes,
18921                 .unsol_event = alc663_g71v_unsol_event,
18922                 .setup = alc663_g71v_setup,
18923                 .init_hook = alc663_g71v_inithook,
18924         },
18925         [ALC663_ASUS_H13] = {
18926                 .mixers = { alc663_m51va_mixer },
18927                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18928                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18929                 .dac_nids = alc662_dac_nids,
18930                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18931                 .channel_mode = alc662_3ST_2ch_modes,
18932                 .unsol_event = alc663_m51va_unsol_event,
18933                 .init_hook = alc663_m51va_inithook,
18934         },
18935         [ALC663_ASUS_G50V] = {
18936                 .mixers = { alc663_g50v_mixer },
18937                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18938                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18939                 .dac_nids = alc662_dac_nids,
18940                 .dig_out_nid = ALC662_DIGOUT_NID,
18941                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18942                 .channel_mode = alc662_3ST_6ch_modes,
18943                 .input_mux = &alc663_capture_source,
18944                 .unsol_event = alc663_g50v_unsol_event,
18945                 .setup = alc663_g50v_setup,
18946                 .init_hook = alc663_g50v_inithook,
18947         },
18948         [ALC663_ASUS_MODE1] = {
18949                 .mixers = { alc663_m51va_mixer },
18950                 .cap_mixer = alc662_auto_capture_mixer,
18951                 .init_verbs = { alc662_init_verbs,
18952                                 alc663_21jd_amic_init_verbs },
18953                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18954                 .hp_nid = 0x03,
18955                 .dac_nids = alc662_dac_nids,
18956                 .dig_out_nid = ALC662_DIGOUT_NID,
18957                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18958                 .channel_mode = alc662_3ST_2ch_modes,
18959                 .unsol_event = alc663_mode1_unsol_event,
18960                 .setup = alc663_mode1_setup,
18961                 .init_hook = alc663_mode1_inithook,
18962         },
18963         [ALC662_ASUS_MODE2] = {
18964                 .mixers = { alc662_1bjd_mixer },
18965                 .cap_mixer = alc662_auto_capture_mixer,
18966                 .init_verbs = { alc662_init_verbs,
18967                                 alc662_1bjd_amic_init_verbs },
18968                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18969                 .dac_nids = alc662_dac_nids,
18970                 .dig_out_nid = ALC662_DIGOUT_NID,
18971                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18972                 .channel_mode = alc662_3ST_2ch_modes,
18973                 .unsol_event = alc662_mode2_unsol_event,
18974                 .setup = alc662_mode2_setup,
18975                 .init_hook = alc662_mode2_inithook,
18976         },
18977         [ALC663_ASUS_MODE3] = {
18978                 .mixers = { alc663_two_hp_m1_mixer },
18979                 .cap_mixer = alc662_auto_capture_mixer,
18980                 .init_verbs = { alc662_init_verbs,
18981                                 alc663_two_hp_amic_m1_init_verbs },
18982                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18983                 .hp_nid = 0x03,
18984                 .dac_nids = alc662_dac_nids,
18985                 .dig_out_nid = ALC662_DIGOUT_NID,
18986                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18987                 .channel_mode = alc662_3ST_2ch_modes,
18988                 .unsol_event = alc663_mode3_unsol_event,
18989                 .setup = alc663_mode3_setup,
18990                 .init_hook = alc663_mode3_inithook,
18991         },
18992         [ALC663_ASUS_MODE4] = {
18993                 .mixers = { alc663_asus_21jd_clfe_mixer },
18994                 .cap_mixer = alc662_auto_capture_mixer,
18995                 .init_verbs = { alc662_init_verbs,
18996                                 alc663_21jd_amic_init_verbs},
18997                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18998                 .hp_nid = 0x03,
18999                 .dac_nids = alc662_dac_nids,
19000                 .dig_out_nid = ALC662_DIGOUT_NID,
19001                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19002                 .channel_mode = alc662_3ST_2ch_modes,
19003                 .unsol_event = alc663_mode4_unsol_event,
19004                 .setup = alc663_mode4_setup,
19005                 .init_hook = alc663_mode4_inithook,
19006         },
19007         [ALC663_ASUS_MODE5] = {
19008                 .mixers = { alc663_asus_15jd_clfe_mixer },
19009                 .cap_mixer = alc662_auto_capture_mixer,
19010                 .init_verbs = { alc662_init_verbs,
19011                                 alc663_15jd_amic_init_verbs },
19012                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19013                 .hp_nid = 0x03,
19014                 .dac_nids = alc662_dac_nids,
19015                 .dig_out_nid = ALC662_DIGOUT_NID,
19016                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19017                 .channel_mode = alc662_3ST_2ch_modes,
19018                 .unsol_event = alc663_mode5_unsol_event,
19019                 .setup = alc663_mode5_setup,
19020                 .init_hook = alc663_mode5_inithook,
19021         },
19022         [ALC663_ASUS_MODE6] = {
19023                 .mixers = { alc663_two_hp_m2_mixer },
19024                 .cap_mixer = alc662_auto_capture_mixer,
19025                 .init_verbs = { alc662_init_verbs,
19026                                 alc663_two_hp_amic_m2_init_verbs },
19027                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19028                 .hp_nid = 0x03,
19029                 .dac_nids = alc662_dac_nids,
19030                 .dig_out_nid = ALC662_DIGOUT_NID,
19031                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19032                 .channel_mode = alc662_3ST_2ch_modes,
19033                 .unsol_event = alc663_mode6_unsol_event,
19034                 .setup = alc663_mode6_setup,
19035                 .init_hook = alc663_mode6_inithook,
19036         },
19037         [ALC663_ASUS_MODE7] = {
19038                 .mixers = { alc663_mode7_mixer },
19039                 .cap_mixer = alc662_auto_capture_mixer,
19040                 .init_verbs = { alc662_init_verbs,
19041                                 alc663_mode7_init_verbs },
19042                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19043                 .hp_nid = 0x03,
19044                 .dac_nids = alc662_dac_nids,
19045                 .dig_out_nid = ALC662_DIGOUT_NID,
19046                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19047                 .channel_mode = alc662_3ST_2ch_modes,
19048                 .unsol_event = alc663_mode7_unsol_event,
19049                 .setup = alc663_mode7_setup,
19050                 .init_hook = alc663_mode7_inithook,
19051         },
19052         [ALC663_ASUS_MODE8] = {
19053                 .mixers = { alc663_mode8_mixer },
19054                 .cap_mixer = alc662_auto_capture_mixer,
19055                 .init_verbs = { alc662_init_verbs,
19056                                 alc663_mode8_init_verbs },
19057                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19058                 .hp_nid = 0x03,
19059                 .dac_nids = alc662_dac_nids,
19060                 .dig_out_nid = ALC662_DIGOUT_NID,
19061                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19062                 .channel_mode = alc662_3ST_2ch_modes,
19063                 .unsol_event = alc663_mode8_unsol_event,
19064                 .setup = alc663_mode8_setup,
19065                 .init_hook = alc663_mode8_inithook,
19066         },
19067         [ALC272_DELL] = {
19068                 .mixers = { alc663_m51va_mixer },
19069                 .cap_mixer = alc272_auto_capture_mixer,
19070                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
19071                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19072                 .dac_nids = alc662_dac_nids,
19073                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19074                 .adc_nids = alc272_adc_nids,
19075                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
19076                 .capsrc_nids = alc272_capsrc_nids,
19077                 .channel_mode = alc662_3ST_2ch_modes,
19078                 .unsol_event = alc663_m51va_unsol_event,
19079                 .setup = alc663_m51va_setup,
19080                 .init_hook = alc663_m51va_inithook,
19081         },
19082         [ALC272_DELL_ZM1] = {
19083                 .mixers = { alc663_m51va_mixer },
19084                 .cap_mixer = alc662_auto_capture_mixer,
19085                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
19086                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19087                 .dac_nids = alc662_dac_nids,
19088                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19089                 .adc_nids = alc662_adc_nids,
19090                 .num_adc_nids = 1,
19091                 .capsrc_nids = alc662_capsrc_nids,
19092                 .channel_mode = alc662_3ST_2ch_modes,
19093                 .unsol_event = alc663_m51va_unsol_event,
19094                 .setup = alc663_m51va_setup,
19095                 .init_hook = alc663_m51va_inithook,
19096         },
19097         [ALC272_SAMSUNG_NC10] = {
19098                 .mixers = { alc272_nc10_mixer },
19099                 .init_verbs = { alc662_init_verbs,
19100                                 alc663_21jd_amic_init_verbs },
19101                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19102                 .dac_nids = alc272_dac_nids,
19103                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19104                 .channel_mode = alc662_3ST_2ch_modes,
19105                 /*.input_mux = &alc272_nc10_capture_source,*/
19106                 .unsol_event = alc663_mode4_unsol_event,
19107                 .setup = alc663_mode4_setup,
19108                 .init_hook = alc663_mode4_inithook,
19109         },
19110 };
19111
19112
19113 /*
19114  * BIOS auto configuration
19115  */
19116
19117 /* convert from MIX nid to DAC */
19118 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
19119 {
19120         if (nid == 0x0f)
19121                 return 0x02;
19122         else if (nid >= 0x0c && nid <= 0x0e)
19123                 return nid - 0x0c + 0x02;
19124         else if (nid == 0x26) /* ALC887-VD has this DAC too */
19125                 return 0x25;
19126         else
19127                 return 0;
19128 }
19129
19130 /* get MIX nid connected to the given pin targeted to DAC */
19131 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
19132                                    hda_nid_t dac)
19133 {
19134         hda_nid_t mix[5];
19135         int i, num;
19136
19137         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
19138         for (i = 0; i < num; i++) {
19139                 if (alc662_mix_to_dac(mix[i]) == dac)
19140                         return mix[i];
19141         }
19142         return 0;
19143 }
19144
19145 /* look for an empty DAC slot */
19146 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
19147 {
19148         struct alc_spec *spec = codec->spec;
19149         hda_nid_t srcs[5];
19150         int i, j, num;
19151
19152         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
19153         if (num < 0)
19154                 return 0;
19155         for (i = 0; i < num; i++) {
19156                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
19157                 if (!nid)
19158                         continue;
19159                 for (j = 0; j < spec->multiout.num_dacs; j++)
19160                         if (spec->multiout.dac_nids[j] == nid)
19161                                 break;
19162                 if (j >= spec->multiout.num_dacs)
19163                         return nid;
19164         }
19165         return 0;
19166 }
19167
19168 /* fill in the dac_nids table from the parsed pin configuration */
19169 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
19170                                      const struct auto_pin_cfg *cfg)
19171 {
19172         struct alc_spec *spec = codec->spec;
19173         int i;
19174         hda_nid_t dac;
19175
19176         spec->multiout.dac_nids = spec->private_dac_nids;
19177         for (i = 0; i < cfg->line_outs; i++) {
19178                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
19179                 if (!dac)
19180                         continue;
19181                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19182         }
19183         return 0;
19184 }
19185
19186 static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
19187                                        hda_nid_t nid, int idx, unsigned int chs)
19188 {
19189         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx,
19190                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19191 }
19192
19193 static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19194                                       hda_nid_t nid, int idx, unsigned int chs)
19195 {
19196         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
19197                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19198 }
19199
19200 #define alc662_add_vol_ctl(spec, pfx, nid, chs) \
19201         __alc662_add_vol_ctl(spec, pfx, nid, 0, chs)
19202 #define alc662_add_sw_ctl(spec, pfx, nid, chs) \
19203         __alc662_add_sw_ctl(spec, pfx, nid, 0, chs)
19204 #define alc662_add_stereo_vol(spec, pfx, nid) \
19205         alc662_add_vol_ctl(spec, pfx, nid, 3)
19206 #define alc662_add_stereo_sw(spec, pfx, nid) \
19207         alc662_add_sw_ctl(spec, pfx, nid, 3)
19208
19209 /* add playback controls from the parsed DAC table */
19210 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19211                                              const struct auto_pin_cfg *cfg)
19212 {
19213         struct alc_spec *spec = codec->spec;
19214         static const char * const chname[4] = {
19215                 "Front", "Surround", NULL /*CLFE*/, "Side"
19216         };
19217         const char *pfx = alc_get_line_out_pfx(cfg, true);
19218         hda_nid_t nid, mix;
19219         int i, err;
19220
19221         for (i = 0; i < cfg->line_outs; i++) {
19222                 nid = spec->multiout.dac_nids[i];
19223                 if (!nid)
19224                         continue;
19225                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
19226                 if (!mix)
19227                         continue;
19228                 if (!pfx && i == 2) {
19229                         /* Center/LFE */
19230                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19231                         if (err < 0)
19232                                 return err;
19233                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19234                         if (err < 0)
19235                                 return err;
19236                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19237                         if (err < 0)
19238                                 return err;
19239                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19240                         if (err < 0)
19241                                 return err;
19242                 } else {
19243                         const char *name = pfx;
19244                         if (!name)
19245                                 name = chname[i];
19246                         err = __alc662_add_vol_ctl(spec, name, nid, i, 3);
19247                         if (err < 0)
19248                                 return err;
19249                         err = __alc662_add_sw_ctl(spec, name, mix, i, 3);
19250                         if (err < 0)
19251                                 return err;
19252                 }
19253         }
19254         return 0;
19255 }
19256
19257 /* add playback controls for speaker and HP outputs */
19258 /* return DAC nid if any new DAC is assigned */
19259 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19260                                         const char *pfx)
19261 {
19262         struct alc_spec *spec = codec->spec;
19263         hda_nid_t nid, mix;
19264         int err;
19265
19266         if (!pin)
19267                 return 0;
19268         nid = alc662_look_for_dac(codec, pin);
19269         if (!nid) {
19270                 /* the corresponding DAC is already occupied */
19271                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19272                         return 0; /* no way */
19273                 /* create a switch only */
19274                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19275                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19276         }
19277
19278         mix = alc662_dac_to_mix(codec, pin, nid);
19279         if (!mix)
19280                 return 0;
19281         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19282         if (err < 0)
19283                 return err;
19284         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19285         if (err < 0)
19286                 return err;
19287         return nid;
19288 }
19289
19290 /* create playback/capture controls for input pins */
19291 #define alc662_auto_create_input_ctls \
19292         alc882_auto_create_input_ctls
19293
19294 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19295                                               hda_nid_t nid, int pin_type,
19296                                               hda_nid_t dac)
19297 {
19298         int i, num;
19299         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19300
19301         alc_set_pin_output(codec, nid, pin_type);
19302         /* need the manual connection? */
19303         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19304         if (num <= 1)
19305                 return;
19306         for (i = 0; i < num; i++) {
19307                 if (alc662_mix_to_dac(srcs[i]) != dac)
19308                         continue;
19309                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19310                 return;
19311         }
19312 }
19313
19314 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19315 {
19316         struct alc_spec *spec = codec->spec;
19317         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19318         int i;
19319
19320         for (i = 0; i <= HDA_SIDE; i++) {
19321                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19322                 if (nid)
19323                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19324                                         spec->multiout.dac_nids[i]);
19325         }
19326 }
19327
19328 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19329 {
19330         struct alc_spec *spec = codec->spec;
19331         hda_nid_t pin;
19332
19333         pin = spec->autocfg.hp_pins[0];
19334         if (pin)
19335                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19336                                                   spec->multiout.hp_nid);
19337         pin = spec->autocfg.speaker_pins[0];
19338         if (pin)
19339                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19340                                         spec->multiout.extra_out_nid[0]);
19341 }
19342
19343 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19344
19345 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19346 {
19347         struct alc_spec *spec = codec->spec;
19348         struct auto_pin_cfg *cfg = &spec->autocfg;
19349         int i;
19350
19351         for (i = 0; i < cfg->num_inputs; i++) {
19352                 hda_nid_t nid = cfg->inputs[i].pin;
19353                 if (alc_is_input_pin(codec, nid)) {
19354                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19355                         if (nid != ALC662_PIN_CD_NID &&
19356                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19357                                 snd_hda_codec_write(codec, nid, 0,
19358                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19359                                                     AMP_OUT_MUTE);
19360                 }
19361         }
19362 }
19363
19364 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19365
19366 static int alc662_parse_auto_config(struct hda_codec *codec)
19367 {
19368         struct alc_spec *spec = codec->spec;
19369         int err;
19370         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19371
19372         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19373                                            alc662_ignore);
19374         if (err < 0)
19375                 return err;
19376         if (!spec->autocfg.line_outs)
19377                 return 0; /* can't find valid BIOS pin config */
19378
19379         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19380         if (err < 0)
19381                 return err;
19382         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19383         if (err < 0)
19384                 return err;
19385         err = alc662_auto_create_extra_out(codec,
19386                                            spec->autocfg.speaker_pins[0],
19387                                            "Speaker");
19388         if (err < 0)
19389                 return err;
19390         if (err)
19391                 spec->multiout.extra_out_nid[0] = err;
19392         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19393                                            "Headphone");
19394         if (err < 0)
19395                 return err;
19396         if (err)
19397                 spec->multiout.hp_nid = err;
19398         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19399         if (err < 0)
19400                 return err;
19401
19402         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19403
19404         alc_auto_parse_digital(codec);
19405
19406         if (spec->kctls.list)
19407                 add_mixer(spec, spec->kctls.list);
19408
19409         spec->num_mux_defs = 1;
19410         spec->input_mux = &spec->private_imux[0];
19411
19412         add_verb(spec, alc662_init_verbs);
19413         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19414             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19415                 add_verb(spec, alc663_init_verbs);
19416
19417         if (codec->vendor_id == 0x10ec0272)
19418                 add_verb(spec, alc272_init_verbs);
19419
19420         err = alc_auto_add_mic_boost(codec);
19421         if (err < 0)
19422                 return err;
19423
19424         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19425             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19426             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19427         else
19428             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19429
19430         return 1;
19431 }
19432
19433 /* additional initialization for auto-configuration model */
19434 static void alc662_auto_init(struct hda_codec *codec)
19435 {
19436         struct alc_spec *spec = codec->spec;
19437         alc662_auto_init_multi_out(codec);
19438         alc662_auto_init_hp_out(codec);
19439         alc662_auto_init_analog_input(codec);
19440         alc662_auto_init_input_src(codec);
19441         alc_auto_init_digital(codec);
19442         if (spec->unsol_event)
19443                 alc_inithook(codec);
19444 }
19445
19446 static void alc272_fixup_mario(struct hda_codec *codec,
19447                                const struct alc_fixup *fix, int action)
19448 {
19449         if (action != ALC_FIXUP_ACT_PROBE)
19450                 return;
19451         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19452                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19453                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19454                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19455                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
19456                 printk(KERN_WARNING
19457                        "hda_codec: failed to override amp caps for NID 0x2\n");
19458 }
19459
19460 enum {
19461         ALC662_FIXUP_ASPIRE,
19462         ALC662_FIXUP_IDEAPAD,
19463         ALC272_FIXUP_MARIO,
19464 };
19465
19466 static const struct alc_fixup alc662_fixups[] = {
19467         [ALC662_FIXUP_ASPIRE] = {
19468                 .type = ALC_FIXUP_PINS,
19469                 .v.pins = (const struct alc_pincfg[]) {
19470                         { 0x15, 0x99130112 }, /* subwoofer */
19471                         { }
19472                 }
19473         },
19474         [ALC662_FIXUP_IDEAPAD] = {
19475                 .type = ALC_FIXUP_PINS,
19476                 .v.pins = (const struct alc_pincfg[]) {
19477                         { 0x17, 0x99130112 }, /* subwoofer */
19478                         { }
19479                 }
19480         },
19481         [ALC272_FIXUP_MARIO] = {
19482                 .type = ALC_FIXUP_FUNC,
19483                 .v.func = alc272_fixup_mario,
19484         }
19485 };
19486
19487 static struct snd_pci_quirk alc662_fixup_tbl[] = {
19488         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19489         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19490         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19491         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19492         {}
19493 };
19494
19495 static const struct alc_model_fixup alc662_fixup_models[] = {
19496         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19497         {}
19498 };
19499
19500
19501 static int patch_alc662(struct hda_codec *codec)
19502 {
19503         struct alc_spec *spec;
19504         int err, board_config;
19505         int coef;
19506
19507         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19508         if (!spec)
19509                 return -ENOMEM;
19510
19511         codec->spec = spec;
19512
19513         alc_auto_parse_customize_define(codec);
19514
19515         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19516
19517         coef = alc_read_coef_idx(codec, 0);
19518         if (coef == 0x8020 || coef == 0x8011)
19519                 alc_codec_rename(codec, "ALC661");
19520         else if (coef & (1 << 14) &&
19521                 codec->bus->pci->subsystem_vendor == 0x1025 &&
19522                 spec->cdefine.platform_type == 1)
19523                 alc_codec_rename(codec, "ALC272X");
19524         else if (coef == 0x4011)
19525                 alc_codec_rename(codec, "ALC656");
19526
19527         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19528                                                   alc662_models,
19529                                                   alc662_cfg_tbl);
19530         if (board_config < 0) {
19531                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19532                        codec->chip_name);
19533                 board_config = ALC662_AUTO;
19534         }
19535
19536         if (board_config == ALC662_AUTO) {
19537                 alc_pick_fixup(codec, alc662_fixup_models,
19538                                alc662_fixup_tbl, alc662_fixups);
19539                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
19540                 /* automatic parse from the BIOS config */
19541                 err = alc662_parse_auto_config(codec);
19542                 if (err < 0) {
19543                         alc_free(codec);
19544                         return err;
19545                 } else if (!err) {
19546                         printk(KERN_INFO
19547                                "hda_codec: Cannot set up configuration "
19548                                "from BIOS.  Using base mode...\n");
19549                         board_config = ALC662_3ST_2ch_DIG;
19550                 }
19551         }
19552
19553         if (has_cdefine_beep(codec)) {
19554                 err = snd_hda_attach_beep_device(codec, 0x1);
19555                 if (err < 0) {
19556                         alc_free(codec);
19557                         return err;
19558                 }
19559         }
19560
19561         if (board_config != ALC662_AUTO)
19562                 setup_preset(codec, &alc662_presets[board_config]);
19563
19564         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19565         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19566
19567         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19568         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19569
19570         if (!spec->adc_nids) {
19571                 spec->adc_nids = alc662_adc_nids;
19572                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19573         }
19574         if (!spec->capsrc_nids)
19575                 spec->capsrc_nids = alc662_capsrc_nids;
19576
19577         if (!spec->cap_mixer)
19578                 set_capture_mixer(codec);
19579
19580         if (has_cdefine_beep(codec)) {
19581                 switch (codec->vendor_id) {
19582                 case 0x10ec0662:
19583                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19584                         break;
19585                 case 0x10ec0272:
19586                 case 0x10ec0663:
19587                 case 0x10ec0665:
19588                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19589                         break;
19590                 case 0x10ec0273:
19591                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19592                         break;
19593                 }
19594         }
19595         spec->vmaster_nid = 0x02;
19596
19597         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
19598
19599         codec->patch_ops = alc_patch_ops;
19600         if (board_config == ALC662_AUTO)
19601                 spec->init_hook = alc662_auto_init;
19602
19603         alc_init_jacks(codec);
19604
19605 #ifdef CONFIG_SND_HDA_POWER_SAVE
19606         if (!spec->loopback.amplist)
19607                 spec->loopback.amplist = alc662_loopbacks;
19608 #endif
19609
19610         return 0;
19611 }
19612
19613 static int patch_alc888(struct hda_codec *codec)
19614 {
19615         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19616                 kfree(codec->chip_name);
19617                 if (codec->vendor_id == 0x10ec0887)
19618                         codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19619                 else
19620                         codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19621                 if (!codec->chip_name) {
19622                         alc_free(codec);
19623                         return -ENOMEM;
19624                 }
19625                 return patch_alc662(codec);
19626         }
19627         return patch_alc882(codec);
19628 }
19629
19630 /*
19631  * ALC680 support
19632  */
19633 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19634 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19635 #define alc680_modes            alc260_modes
19636
19637 static hda_nid_t alc680_dac_nids[3] = {
19638         /* Lout1, Lout2, hp */
19639         0x02, 0x03, 0x04
19640 };
19641
19642 static hda_nid_t alc680_adc_nids[3] = {
19643         /* ADC0-2 */
19644         /* DMIC, MIC, Line-in*/
19645         0x07, 0x08, 0x09
19646 };
19647
19648 /*
19649  * Analog capture ADC cgange
19650  */
19651 static void alc680_rec_autoswitch(struct hda_codec *codec)
19652 {
19653         struct alc_spec *spec = codec->spec;
19654         struct auto_pin_cfg *cfg = &spec->autocfg;
19655         int pin_found = 0;
19656         int type_found = AUTO_PIN_LAST;
19657         hda_nid_t nid;
19658         int i;
19659
19660         for (i = 0; i < cfg->num_inputs; i++) {
19661                 nid = cfg->inputs[i].pin;
19662                 if (!(snd_hda_query_pin_caps(codec, nid) &
19663                       AC_PINCAP_PRES_DETECT))
19664                         continue;
19665                 if (snd_hda_jack_detect(codec, nid)) {
19666                         if (cfg->inputs[i].type < type_found) {
19667                                 type_found = cfg->inputs[i].type;
19668                                 pin_found = nid;
19669                         }
19670                 }
19671         }
19672
19673         nid = 0x07;
19674         if (pin_found)
19675                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19676
19677         if (nid != spec->cur_adc)
19678                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19679         spec->cur_adc = nid;
19680         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19681                                    spec->cur_adc_format);
19682 }
19683
19684 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19685                                       struct hda_codec *codec,
19686                                       unsigned int stream_tag,
19687                                       unsigned int format,
19688                                       struct snd_pcm_substream *substream)
19689 {
19690         struct alc_spec *spec = codec->spec;
19691
19692         spec->cur_adc = 0x07;
19693         spec->cur_adc_stream_tag = stream_tag;
19694         spec->cur_adc_format = format;
19695
19696         alc680_rec_autoswitch(codec);
19697         return 0;
19698 }
19699
19700 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19701                                       struct hda_codec *codec,
19702                                       struct snd_pcm_substream *substream)
19703 {
19704         snd_hda_codec_cleanup_stream(codec, 0x07);
19705         snd_hda_codec_cleanup_stream(codec, 0x08);
19706         snd_hda_codec_cleanup_stream(codec, 0x09);
19707         return 0;
19708 }
19709
19710 static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19711         .substreams = 1, /* can be overridden */
19712         .channels_min = 2,
19713         .channels_max = 2,
19714         /* NID is set in alc_build_pcms */
19715         .ops = {
19716                 .prepare = alc680_capture_pcm_prepare,
19717                 .cleanup = alc680_capture_pcm_cleanup
19718         },
19719 };
19720
19721 static struct snd_kcontrol_new alc680_base_mixer[] = {
19722         /* output mixer control */
19723         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19724         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19725         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19726         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19727         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
19728         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
19729         HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
19730         { }
19731 };
19732
19733 static struct hda_bind_ctls alc680_bind_cap_vol = {
19734         .ops = &snd_hda_bind_vol,
19735         .values = {
19736                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19737                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19738                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19739                 0
19740         },
19741 };
19742
19743 static struct hda_bind_ctls alc680_bind_cap_switch = {
19744         .ops = &snd_hda_bind_sw,
19745         .values = {
19746                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19747                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19748                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19749                 0
19750         },
19751 };
19752
19753 static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19754         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19755         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19756         { } /* end */
19757 };
19758
19759 /*
19760  * generic initialization of ADC, input mixers and output mixers
19761  */
19762 static struct hda_verb alc680_init_verbs[] = {
19763         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19764         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19765         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19766
19767         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19768         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19769         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19770         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19771         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19772         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19773
19774         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19775         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19776         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19777         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19778         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19779
19780         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19781         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19782         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19783
19784         { }
19785 };
19786
19787 /* toggle speaker-output according to the hp-jack state */
19788 static void alc680_base_setup(struct hda_codec *codec)
19789 {
19790         struct alc_spec *spec = codec->spec;
19791
19792         spec->autocfg.hp_pins[0] = 0x16;
19793         spec->autocfg.speaker_pins[0] = 0x14;
19794         spec->autocfg.speaker_pins[1] = 0x15;
19795         spec->autocfg.num_inputs = 2;
19796         spec->autocfg.inputs[0].pin = 0x18;
19797         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19798         spec->autocfg.inputs[1].pin = 0x19;
19799         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19800 }
19801
19802 static void alc680_unsol_event(struct hda_codec *codec,
19803                                            unsigned int res)
19804 {
19805         if ((res >> 26) == ALC880_HP_EVENT)
19806                 alc_automute_amp(codec);
19807         if ((res >> 26) == ALC880_MIC_EVENT)
19808                 alc680_rec_autoswitch(codec);
19809 }
19810
19811 static void alc680_inithook(struct hda_codec *codec)
19812 {
19813         alc_automute_amp(codec);
19814         alc680_rec_autoswitch(codec);
19815 }
19816
19817 /* create input playback/capture controls for the given pin */
19818 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19819                                     const char *ctlname, int idx)
19820 {
19821         hda_nid_t dac;
19822         int err;
19823
19824         switch (nid) {
19825         case 0x14:
19826                 dac = 0x02;
19827                 break;
19828         case 0x15:
19829                 dac = 0x03;
19830                 break;
19831         case 0x16:
19832                 dac = 0x04;
19833                 break;
19834         default:
19835                 return 0;
19836         }
19837         if (spec->multiout.dac_nids[0] != dac &&
19838             spec->multiout.dac_nids[1] != dac) {
19839                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19840                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19841                                                       HDA_OUTPUT));
19842                 if (err < 0)
19843                         return err;
19844
19845                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19846                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19847
19848                 if (err < 0)
19849                         return err;
19850                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19851         }
19852
19853         return 0;
19854 }
19855
19856 /* add playback controls from the parsed DAC table */
19857 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19858                                              const struct auto_pin_cfg *cfg)
19859 {
19860         hda_nid_t nid;
19861         int err;
19862
19863         spec->multiout.dac_nids = spec->private_dac_nids;
19864
19865         nid = cfg->line_out_pins[0];
19866         if (nid) {
19867                 const char *name;
19868                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19869                         name = "Speaker";
19870                 else
19871                         name = "Front";
19872                 err = alc680_new_analog_output(spec, nid, name, 0);
19873                 if (err < 0)
19874                         return err;
19875         }
19876
19877         nid = cfg->speaker_pins[0];
19878         if (nid) {
19879                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19880                 if (err < 0)
19881                         return err;
19882         }
19883         nid = cfg->hp_pins[0];
19884         if (nid) {
19885                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19886                 if (err < 0)
19887                         return err;
19888         }
19889
19890         return 0;
19891 }
19892
19893 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19894                                               hda_nid_t nid, int pin_type)
19895 {
19896         alc_set_pin_output(codec, nid, pin_type);
19897 }
19898
19899 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19900 {
19901         struct alc_spec *spec = codec->spec;
19902         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19903         if (nid) {
19904                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19905                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19906         }
19907 }
19908
19909 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19910 {
19911         struct alc_spec *spec = codec->spec;
19912         hda_nid_t pin;
19913
19914         pin = spec->autocfg.hp_pins[0];
19915         if (pin)
19916                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19917         pin = spec->autocfg.speaker_pins[0];
19918         if (pin)
19919                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19920 }
19921
19922 /* pcm configuration: identical with ALC880 */
19923 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19924 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19925 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19926 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19927 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19928
19929 /*
19930  * BIOS auto configuration
19931  */
19932 static int alc680_parse_auto_config(struct hda_codec *codec)
19933 {
19934         struct alc_spec *spec = codec->spec;
19935         int err;
19936         static hda_nid_t alc680_ignore[] = { 0 };
19937
19938         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19939                                            alc680_ignore);
19940         if (err < 0)
19941                 return err;
19942
19943         if (!spec->autocfg.line_outs) {
19944                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19945                         spec->multiout.max_channels = 2;
19946                         spec->no_analog = 1;
19947                         goto dig_only;
19948                 }
19949                 return 0; /* can't find valid BIOS pin config */
19950         }
19951         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19952         if (err < 0)
19953                 return err;
19954
19955         spec->multiout.max_channels = 2;
19956
19957  dig_only:
19958         /* digital only support output */
19959         alc_auto_parse_digital(codec);
19960         if (spec->kctls.list)
19961                 add_mixer(spec, spec->kctls.list);
19962
19963         add_verb(spec, alc680_init_verbs);
19964
19965         err = alc_auto_add_mic_boost(codec);
19966         if (err < 0)
19967                 return err;
19968
19969         return 1;
19970 }
19971
19972 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19973
19974 /* init callback for auto-configuration model -- overriding the default init */
19975 static void alc680_auto_init(struct hda_codec *codec)
19976 {
19977         struct alc_spec *spec = codec->spec;
19978         alc680_auto_init_multi_out(codec);
19979         alc680_auto_init_hp_out(codec);
19980         alc680_auto_init_analog_input(codec);
19981         alc_auto_init_digital(codec);
19982         if (spec->unsol_event)
19983                 alc_inithook(codec);
19984 }
19985
19986 /*
19987  * configuration and preset
19988  */
19989 static const char * const alc680_models[ALC680_MODEL_LAST] = {
19990         [ALC680_BASE]           = "base",
19991         [ALC680_AUTO]           = "auto",
19992 };
19993
19994 static struct snd_pci_quirk alc680_cfg_tbl[] = {
19995         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19996         {}
19997 };
19998
19999 static struct alc_config_preset alc680_presets[] = {
20000         [ALC680_BASE] = {
20001                 .mixers = { alc680_base_mixer },
20002                 .cap_mixer =  alc680_master_capture_mixer,
20003                 .init_verbs = { alc680_init_verbs },
20004                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
20005                 .dac_nids = alc680_dac_nids,
20006                 .dig_out_nid = ALC680_DIGOUT_NID,
20007                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
20008                 .channel_mode = alc680_modes,
20009                 .unsol_event = alc680_unsol_event,
20010                 .setup = alc680_base_setup,
20011                 .init_hook = alc680_inithook,
20012
20013         },
20014 };
20015
20016 static int patch_alc680(struct hda_codec *codec)
20017 {
20018         struct alc_spec *spec;
20019         int board_config;
20020         int err;
20021
20022         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
20023         if (spec == NULL)
20024                 return -ENOMEM;
20025
20026         codec->spec = spec;
20027
20028         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
20029                                                   alc680_models,
20030                                                   alc680_cfg_tbl);
20031
20032         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
20033                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
20034                        codec->chip_name);
20035                 board_config = ALC680_AUTO;
20036         }
20037
20038         if (board_config == ALC680_AUTO) {
20039                 /* automatic parse from the BIOS config */
20040                 err = alc680_parse_auto_config(codec);
20041                 if (err < 0) {
20042                         alc_free(codec);
20043                         return err;
20044                 } else if (!err) {
20045                         printk(KERN_INFO
20046                                "hda_codec: Cannot set up configuration "
20047                                "from BIOS.  Using base mode...\n");
20048                         board_config = ALC680_BASE;
20049                 }
20050         }
20051
20052         if (board_config != ALC680_AUTO)
20053                 setup_preset(codec, &alc680_presets[board_config]);
20054
20055         spec->stream_analog_playback = &alc680_pcm_analog_playback;
20056         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
20057         spec->stream_digital_playback = &alc680_pcm_digital_playback;
20058         spec->stream_digital_capture = &alc680_pcm_digital_capture;
20059
20060         if (!spec->adc_nids) {
20061                 spec->adc_nids = alc680_adc_nids;
20062                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
20063         }
20064
20065         if (!spec->cap_mixer)
20066                 set_capture_mixer(codec);
20067
20068         spec->vmaster_nid = 0x02;
20069
20070         codec->patch_ops = alc_patch_ops;
20071         if (board_config == ALC680_AUTO)
20072                 spec->init_hook = alc680_auto_init;
20073
20074         return 0;
20075 }
20076
20077 /*
20078  * patch entries
20079  */
20080 static struct hda_codec_preset snd_hda_preset_realtek[] = {
20081         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
20082         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
20083         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
20084         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
20085         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
20086         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
20087         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
20088         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
20089         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
20090           .patch = patch_alc861 },
20091         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
20092         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
20093         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
20094         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
20095           .patch = patch_alc882 },
20096         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
20097           .patch = patch_alc662 },
20098         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
20099         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
20100         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
20101         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
20102         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
20103         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
20104         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
20105         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
20106           .patch = patch_alc882 },
20107         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
20108           .patch = patch_alc882 },
20109         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
20110         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
20111         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
20112           .patch = patch_alc882 },
20113         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20114         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20115         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20116         {} /* terminator */
20117 };
20118
20119 MODULE_ALIAS("snd-hda-codec-id:10ec*");
20120
20121 MODULE_LICENSE("GPL");
20122 MODULE_DESCRIPTION("Realtek HD-audio codec");
20123
20124 static struct hda_codec_preset_list realtek_list = {
20125         .preset = snd_hda_preset_realtek,
20126         .owner = THIS_MODULE,
20127 };
20128
20129 static int __init patch_realtek_init(void)
20130 {
20131         return snd_hda_add_codec_preset(&realtek_list);
20132 }
20133
20134 static void __exit patch_realtek_exit(void)
20135 {
20136         snd_hda_delete_codec_preset(&realtek_list);
20137 }
20138
20139 module_init(patch_realtek_init)
20140 module_exit(patch_realtek_exit)