SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_AMIC,
 135         ALC269_ASUS_DMIC,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC663_ASUS_MODE7,
 192         ALC663_ASUS_MODE8,
 193         ALC272_DELL,
 194         ALC272_DELL_ZM1,
 195         ALC272_SAMSUNG_NC10,
 196         ALC662_AUTO,
 197         ALC662_MODEL_LAST,
 198 };
 199
 200 /* ALC882 models */
 201 enum {
 202         ALC882_3ST_DIG,
 203         ALC882_6ST_DIG,
 204         ALC882_ARIMA,
 205         ALC882_W2JC,
 206         ALC882_TARGA,
 207         ALC882_ASUS_A7J,
 208         ALC882_ASUS_A7M,
 209         ALC885_MACPRO,
 210         ALC885_MBP3,
 211         ALC885_MB5,
 212         ALC885_IMAC24,
 213         ALC885_IMAC91,
 214         ALC883_3ST_2ch_DIG,
 215         ALC883_3ST_6ch_DIG,
 216         ALC883_3ST_6ch,
 217         ALC883_6ST_DIG,
 218         ALC883_TARGA_DIG,
 219         ALC883_TARGA_2ch_DIG,
 220         ALC883_TARGA_8ch_DIG,
 221         ALC883_ACER,
 222         ALC883_ACER_ASPIRE,
 223         ALC888_ACER_ASPIRE_4930G,
 224         ALC888_ACER_ASPIRE_6530G,
 225         ALC888_ACER_ASPIRE_8930G,
 226         ALC888_ACER_ASPIRE_7730G,
 227         ALC883_MEDION,
 228         ALC883_MEDION_MD2,
 229         ALC883_LAPTOP_EAPD,
 230         ALC883_LENOVO_101E_2ch,
 231         ALC883_LENOVO_NB0763,
 232         ALC888_LENOVO_MS7195_DIG,
 233         ALC888_LENOVO_SKY,
 234         ALC883_HAIER_W66,
 235         ALC888_3ST_HP,
 236         ALC888_6ST_DELL,
 237         ALC883_MITAC,
 238         ALC883_CLEVO_M540R,
 239         ALC883_CLEVO_M720,
 240         ALC883_FUJITSU_PI2515,
 241         ALC888_FUJITSU_XA3530,
 242         ALC883_3ST_6ch_INTEL,
 243         ALC889A_INTEL,
 244         ALC889_INTEL,
 245         ALC888_ASUS_M90V,
 246         ALC888_ASUS_EEE1601,
 247         ALC889A_MB31,
 248         ALC1200_ASUS_P5Q,
 249         ALC883_SONY_VAIO_TT,
 250         ALC882_AUTO,
 251         ALC882_MODEL_LAST,
 252 };
 253
 254 /* for GPIO Poll */
 255 #define GPIO_MASK       0x03
 256
 257 /* extra amp-initialization sequence types */
 258 enum {
 259         ALC_INIT_NONE,
 260         ALC_INIT_DEFAULT,
 261         ALC_INIT_GPIO1,
 262         ALC_INIT_GPIO2,
 263         ALC_INIT_GPIO3,
 264 };
 265
 266 struct alc_mic_route {
 267         hda_nid_t pin;
 268         unsigned char mux_idx;
 269         unsigned char amix_idx;
 270 };
 271
 272 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 273
 274 struct alc_spec {
 275         /* codec parameterization */
 276         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 277         unsigned int num_mixers;
 278         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 279         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 280
 281         const struct hda_verb *init_verbs[10];  /* initialization verbs
 282                                                  * don't forget NULL
 283                                                  * termination!
 284                                                  */
 285         unsigned int num_init_verbs;
 286
 287         char stream_name_analog[32];    /* analog PCM stream */
 288         struct hda_pcm_stream *stream_analog_playback;
 289         struct hda_pcm_stream *stream_analog_capture;
 290         struct hda_pcm_stream *stream_analog_alt_playback;
 291         struct hda_pcm_stream *stream_analog_alt_capture;
 292
 293         char stream_name_digital[32];   /* digital PCM stream */
 294         struct hda_pcm_stream *stream_digital_playback;
 295         struct hda_pcm_stream *stream_digital_capture;
 296
 297         /* playback */
 298         struct hda_multi_out multiout;  /* playback set-up
 299                                          * max_channels, dacs must be set
 300                                          * dig_out_nid and hp_nid are optional
 301                                          */
 302         hda_nid_t alt_dac_nid;
 303         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 304         int dig_out_type;
 305
 306         /* capture */
 307         unsigned int num_adc_nids;
 308         hda_nid_t *adc_nids;
 309         hda_nid_t *capsrc_nids;
 310         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 311
 312         /* capture source */
 313         unsigned int num_mux_defs;
 314         const struct hda_input_mux *input_mux;
 315         unsigned int cur_mux[3];
 316         struct alc_mic_route ext_mic;
 317         struct alc_mic_route int_mic;
 318
 319         /* channel model */
 320         const struct hda_channel_mode *channel_mode;
 321         int num_channel_mode;
 322         int need_dac_fix;
 323         int const_channel_count;
 324         int ext_channel_count;
 325
 326         /* PCM information */
 327         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 328
 329         /* dynamic controls, init_verbs and input_mux */
 330         struct auto_pin_cfg autocfg;
 331         struct snd_array kctls;
 332         struct hda_input_mux private_imux[3];
 333         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 334         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 335         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 336
 337         /* hooks */
 338         void (*init_hook)(struct hda_codec *codec);
 339         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 340 #ifdef CONFIG_SND_HDA_POWER_SAVE
 341         void (*power_hook)(struct hda_codec *codec, int power);
 342 #endif
 343
 344         /* for pin sensing */
 345         unsigned int sense_updated: 1;
 346         unsigned int jack_present: 1;
 347         unsigned int master_sw: 1;
 348         unsigned int auto_mic:1;
 349
 350         /* other flags */
 351         unsigned int no_analog :1; /* digital I/O only */
 352         int init_amp;
 353
 354         /* for virtual master */
 355         hda_nid_t vmaster_nid;
 356 #ifdef CONFIG_SND_HDA_POWER_SAVE
 357         struct hda_loopback_check loopback;
 358 #endif
 359
 360         /* for PLL fix */
 361         hda_nid_t pll_nid;
 362         unsigned int pll_coef_idx, pll_coef_bit;
 363 };
 364
 365 /*
 366  * configuration template - to be copied to the spec instance
 367  */
 368 struct alc_config_preset {
 369         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 370                                              * with spec
 371                                              */
 372         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 373         const struct hda_verb *init_verbs[5];
 374         unsigned int num_dacs;
 375         hda_nid_t *dac_nids;
 376         hda_nid_t dig_out_nid;          /* optional */
 377         hda_nid_t hp_nid;               /* optional */
 378         hda_nid_t *slave_dig_outs;
 379         unsigned int num_adc_nids;
 380         hda_nid_t *adc_nids;
 381         hda_nid_t *capsrc_nids;
 382         hda_nid_t dig_in_nid;
 383         unsigned int num_channel_mode;
 384         const struct hda_channel_mode *channel_mode;
 385         int need_dac_fix;
 386         int const_channel_count;
 387         unsigned int num_mux_defs;
 388         const struct hda_input_mux *input_mux;
 389         void (*unsol_event)(struct hda_codec *, unsigned int);
 390         void (*setup)(struct hda_codec *);
 391         void (*init_hook)(struct hda_codec *);
 392 #ifdef CONFIG_SND_HDA_POWER_SAVE
 393         struct hda_amp_list *loopbacks;
 394         void (*power_hook)(struct hda_codec *codec, int power);
 395 #endif
 396 };
 397
 398
 399 /*
 400  * input MUX handling
 401  */
 402 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 403                              struct snd_ctl_elem_info *uinfo)
 404 {
 405         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 406         struct alc_spec *spec = codec->spec;
 407         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 408         if (mux_idx >= spec->num_mux_defs)
 409                 mux_idx = 0;
 410         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 411 }
 412
 413 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 414                             struct snd_ctl_elem_value *ucontrol)
 415 {
 416         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 417         struct alc_spec *spec = codec->spec;
 418         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 419
 420         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 421         return 0;
 422 }
 423
 424 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 425                             struct snd_ctl_elem_value *ucontrol)
 426 {
 427         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 428         struct alc_spec *spec = codec->spec;
 429         const struct hda_input_mux *imux;
 430         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 431         unsigned int mux_idx;
 432         hda_nid_t nid = spec->capsrc_nids ?
 433                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 434         unsigned int type;
 435
 436         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 437         imux = &spec->input_mux[mux_idx];
 438
 439         type = get_wcaps_type(get_wcaps(codec, nid));
 440         if (type == AC_WID_AUD_MIX) {
 441                 /* Matrix-mixer style (e.g. ALC882) */
 442                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 443                 unsigned int i, idx;
 444
 445                 idx = ucontrol->value.enumerated.item[0];
 446                 if (idx >= imux->num_items)
 447                         idx = imux->num_items - 1;
 448                 if (*cur_val == idx)
 449                         return 0;
 450                 for (i = 0; i < imux->num_items; i++) {
 451                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 452                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 453                                                  imux->items[i].index,
 454                                                  HDA_AMP_MUTE, v);
 455                 }
 456                 *cur_val = idx;
 457                 return 1;
 458         } else {
 459                 /* MUX style (e.g. ALC880) */
 460                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 461                                              &spec->cur_mux[adc_idx]);
 462         }
 463 }
 464
 465 /*
 466  * channel mode setting
 467  */
 468 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 469                             struct snd_ctl_elem_info *uinfo)
 470 {
 471         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 472         struct alc_spec *spec = codec->spec;
 473         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 474                                     spec->num_channel_mode);
 475 }
 476
 477 static int alc_ch_mode_get(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         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 483                                    spec->num_channel_mode,
 484                                    spec->ext_channel_count);
 485 }
 486
 487 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 488                            struct snd_ctl_elem_value *ucontrol)
 489 {
 490         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 491         struct alc_spec *spec = codec->spec;
 492         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 493                                       spec->num_channel_mode,
 494                                       &spec->ext_channel_count);
 495         if (err >= 0 && !spec->const_channel_count) {
 496                 spec->multiout.max_channels = spec->ext_channel_count;
 497                 if (spec->need_dac_fix)
 498                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 499         }
 500         return err;
 501 }
 502
 503 /*
 504  * Control the mode of pin widget settings via the mixer.  "pc" is used
 505  * instead of "%" to avoid consequences of accidently treating the % as
 506  * being part of a format specifier.  Maximum allowed length of a value is
 507  * 63 characters plus NULL terminator.
 508  *
 509  * Note: some retasking pin complexes seem to ignore requests for input
 510  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 511  * are requested.  Therefore order this list so that this behaviour will not
 512  * cause problems when mixer clients move through the enum sequentially.
 513  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 514  * March 2006.
 515  */
 516 static char *alc_pin_mode_names[] = {
 517         "Mic 50pc bias", "Mic 80pc bias",
 518         "Line in", "Line out", "Headphone out",
 519 };
 520 static unsigned char alc_pin_mode_values[] = {
 521         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 522 };
 523 /* The control can present all 5 options, or it can limit the options based
 524  * in the pin being assumed to be exclusively an input or an output pin.  In
 525  * addition, "input" pins may or may not process the mic bias option
 526  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 527  * accept requests for bias as of chip versions up to March 2006) and/or
 528  * wiring in the computer.
 529  */
 530 #define ALC_PIN_DIR_IN              0x00
 531 #define ALC_PIN_DIR_OUT             0x01
 532 #define ALC_PIN_DIR_INOUT           0x02
 533 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 534 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 535
 536 /* Info about the pin modes supported by the different pin direction modes.
 537  * For each direction the minimum and maximum values are given.
 538  */
 539 static signed char alc_pin_mode_dir_info[5][2] = {
 540         { 0, 2 },    /* ALC_PIN_DIR_IN */
 541         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 542         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 543         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 544         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 545 };
 546 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 547 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 548 #define alc_pin_mode_n_items(_dir) \
 549         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 550
 551 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 552                              struct snd_ctl_elem_info *uinfo)
 553 {
 554         unsigned int item_num = uinfo->value.enumerated.item;
 555         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 556
 557         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 558         uinfo->count = 1;
 559         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 560
 561         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 562                 item_num = alc_pin_mode_min(dir);
 563         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 564         return 0;
 565 }
 566
 567 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 568                             struct snd_ctl_elem_value *ucontrol)
 569 {
 570         unsigned int i;
 571         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 572         hda_nid_t nid = kcontrol->private_value & 0xffff;
 573         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 574         long *valp = ucontrol->value.integer.value;
 575         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 576                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 577                                                  0x00);
 578
 579         /* Find enumerated value for current pinctl setting */
 580         i = alc_pin_mode_min(dir);
 581         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 582                 i++;
 583         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 584         return 0;
 585 }
 586
 587 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 588                             struct snd_ctl_elem_value *ucontrol)
 589 {
 590         signed int change;
 591         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 592         hda_nid_t nid = kcontrol->private_value & 0xffff;
 593         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 594         long val = *ucontrol->value.integer.value;
 595         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 596                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 597                                                  0x00);
 598
 599         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 600                 val = alc_pin_mode_min(dir);
 601
 602         change = pinctl != alc_pin_mode_values[val];
 603         if (change) {
 604                 /* Set pin mode to that requested */
 605                 snd_hda_codec_write_cache(codec, nid, 0,
 606                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 607                                           alc_pin_mode_values[val]);
 608
 609                 /* Also enable the retasking pin's input/output as required
 610                  * for the requested pin mode.  Enum values of 2 or less are
 611                  * input modes.
 612                  *
 613                  * Dynamically switching the input/output buffers probably
 614                  * reduces noise slightly (particularly on input) so we'll
 615                  * do it.  However, having both input and output buffers
 616                  * enabled simultaneously doesn't seem to be problematic if
 617                  * this turns out to be necessary in the future.
 618                  */
 619                 if (val <= 2) {
 620                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 621                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 622                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 623                                                  HDA_AMP_MUTE, 0);
 624                 } else {
 625                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 626                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 627                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 628                                                  HDA_AMP_MUTE, 0);
 629                 }
 630         }
 631         return change;
 632 }
 633
 634 #define ALC_PIN_MODE(xname, nid, dir) \
 635         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 636           .info = alc_pin_mode_info, \
 637           .get = alc_pin_mode_get, \
 638           .put = alc_pin_mode_put, \
 639           .private_value = nid | (dir<<16) }
 640
 641 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 642  * together using a mask with more than one bit set.  This control is
 643  * currently used only by the ALC260 test model.  At this stage they are not
 644  * needed for any "production" models.
 645  */
 646 #ifdef CONFIG_SND_DEBUG
 647 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 648
 649 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 650                              struct snd_ctl_elem_value *ucontrol)
 651 {
 652         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 653         hda_nid_t nid = kcontrol->private_value & 0xffff;
 654         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 655         long *valp = ucontrol->value.integer.value;
 656         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 657                                               AC_VERB_GET_GPIO_DATA, 0x00);
 658
 659         *valp = (val & mask) != 0;
 660         return 0;
 661 }
 662 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 663                              struct snd_ctl_elem_value *ucontrol)
 664 {
 665         signed int change;
 666         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 667         hda_nid_t nid = kcontrol->private_value & 0xffff;
 668         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 669         long val = *ucontrol->value.integer.value;
 670         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 671                                                     AC_VERB_GET_GPIO_DATA,
 672                                                     0x00);
 673
 674         /* Set/unset the masked GPIO bit(s) as needed */
 675         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 676         if (val == 0)
 677                 gpio_data &= ~mask;
 678         else
 679                 gpio_data |= mask;
 680         snd_hda_codec_write_cache(codec, nid, 0,
 681                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 682
 683         return change;
 684 }
 685 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 686         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 687           .info = alc_gpio_data_info, \
 688           .get = alc_gpio_data_get, \
 689           .put = alc_gpio_data_put, \
 690           .private_value = nid | (mask<<16) }
 691 #endif   /* CONFIG_SND_DEBUG */
 692
 693 /* A switch control to allow the enabling of the digital IO pins on the
 694  * ALC260.  This is incredibly simplistic; the intention of this control is
 695  * to provide something in the test model allowing digital outputs to be
 696  * identified if present.  If models are found which can utilise these
 697  * outputs a more complete mixer control can be devised for those models if
 698  * necessary.
 699  */
 700 #ifdef CONFIG_SND_DEBUG
 701 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 702
 703 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 704                               struct snd_ctl_elem_value *ucontrol)
 705 {
 706         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 707         hda_nid_t nid = kcontrol->private_value & 0xffff;
 708         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 709         long *valp = ucontrol->value.integer.value;
 710         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 711                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 712
 713         *valp = (val & mask) != 0;
 714         return 0;
 715 }
 716 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 717                               struct snd_ctl_elem_value *ucontrol)
 718 {
 719         signed int change;
 720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 721         hda_nid_t nid = kcontrol->private_value & 0xffff;
 722         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 723         long val = *ucontrol->value.integer.value;
 724         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 725                                                     AC_VERB_GET_DIGI_CONVERT_1,
 726                                                     0x00);
 727
 728         /* Set/unset the masked control bit(s) as needed */
 729         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 730         if (val==0)
 731                 ctrl_data &= ~mask;
 732         else
 733                 ctrl_data |= mask;
 734         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 735                                   ctrl_data);
 736
 737         return change;
 738 }
 739 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 740         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 741           .info = alc_spdif_ctrl_info, \
 742           .get = alc_spdif_ctrl_get, \
 743           .put = alc_spdif_ctrl_put, \
 744           .private_value = nid | (mask<<16) }
 745 #endif   /* CONFIG_SND_DEBUG */
 746
 747 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 748  * Again, this is only used in the ALC26x test models to help identify when
 749  * the EAPD line must be asserted for features to work.
 750  */
 751 #ifdef CONFIG_SND_DEBUG
 752 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 753
 754 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 755                               struct snd_ctl_elem_value *ucontrol)
 756 {
 757         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 758         hda_nid_t nid = kcontrol->private_value & 0xffff;
 759         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 760         long *valp = ucontrol->value.integer.value;
 761         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 762                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 763
 764         *valp = (val & mask) != 0;
 765         return 0;
 766 }
 767
 768 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 769                               struct snd_ctl_elem_value *ucontrol)
 770 {
 771         int change;
 772         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 773         hda_nid_t nid = kcontrol->private_value & 0xffff;
 774         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 775         long val = *ucontrol->value.integer.value;
 776         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 777                                                     AC_VERB_GET_EAPD_BTLENABLE,
 778                                                     0x00);
 779
 780         /* Set/unset the masked control bit(s) as needed */
 781         change = (!val ? 0 : mask) != (ctrl_data & mask);
 782         if (!val)
 783                 ctrl_data &= ~mask;
 784         else
 785                 ctrl_data |= mask;
 786         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 787                                   ctrl_data);
 788
 789         return change;
 790 }
 791
 792 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 793         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 794           .info = alc_eapd_ctrl_info, \
 795           .get = alc_eapd_ctrl_get, \
 796           .put = alc_eapd_ctrl_put, \
 797           .private_value = nid | (mask<<16) }
 798 #endif   /* CONFIG_SND_DEBUG */
 799
 800 /*
 801  * set up the input pin config (depending on the given auto-pin type)
 802  */
 803 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 804                               int auto_pin_type)
 805 {
 806         unsigned int val = PIN_IN;
 807
 808         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 809                 unsigned int pincap;
 810                 pincap = snd_hda_query_pin_caps(codec, nid);
 811                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 812                 if (pincap & AC_PINCAP_VREF_80)
 813                         val = PIN_VREF80;
 814                 else if (pincap & AC_PINCAP_VREF_50)
 815                         val = PIN_VREF50;
 816                 else if (pincap & AC_PINCAP_VREF_100)
 817                         val = PIN_VREF100;
 818                 else if (pincap & AC_PINCAP_VREF_GRD)
 819                         val = PIN_VREFGRD;
 820         }
 821         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 822 }
 823
 824 /*
 825  */
 826 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 827 {
 828         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 829                 return;
 830         spec->mixers[spec->num_mixers++] = mix;
 831 }
 832
 833 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 834 {
 835         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 836                 return;
 837         spec->init_verbs[spec->num_init_verbs++] = verb;
 838 }
 839
 840 #ifdef CONFIG_PROC_FS
 841 /*
 842  * hook for proc
 843  */
 844 static void print_realtek_coef(struct snd_info_buffer *buffer,
 845                                struct hda_codec *codec, hda_nid_t nid)
 846 {
 847         int coeff;
 848
 849         if (nid != 0x20)
 850                 return;
 851         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 852         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 853         coeff = snd_hda_codec_read(codec, nid, 0,
 854                                    AC_VERB_GET_COEF_INDEX, 0);
 855         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 856 }
 857 #else
 858 #define print_realtek_coef      NULL
 859 #endif
 860
 861 /*
 862  * set up from the preset table
 863  */
 864 static void setup_preset(struct hda_codec *codec,
 865                          const struct alc_config_preset *preset)
 866 {
 867         struct alc_spec *spec = codec->spec;
 868         int i;
 869
 870         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 871                 add_mixer(spec, preset->mixers[i]);
 872         spec->cap_mixer = preset->cap_mixer;
 873         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 874              i++)
 875                 add_verb(spec, preset->init_verbs[i]);
 876
 877         spec->channel_mode = preset->channel_mode;
 878         spec->num_channel_mode = preset->num_channel_mode;
 879         spec->need_dac_fix = preset->need_dac_fix;
 880         spec->const_channel_count = preset->const_channel_count;
 881
 882         if (preset->const_channel_count)
 883                 spec->multiout.max_channels = preset->const_channel_count;
 884         else
 885                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 886         spec->ext_channel_count = spec->channel_mode[0].channels;
 887
 888         spec->multiout.num_dacs = preset->num_dacs;
 889         spec->multiout.dac_nids = preset->dac_nids;
 890         spec->multiout.dig_out_nid = preset->dig_out_nid;
 891         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 892         spec->multiout.hp_nid = preset->hp_nid;
 893
 894         spec->num_mux_defs = preset->num_mux_defs;
 895         if (!spec->num_mux_defs)
 896                 spec->num_mux_defs = 1;
 897         spec->input_mux = preset->input_mux;
 898
 899         spec->num_adc_nids = preset->num_adc_nids;
 900         spec->adc_nids = preset->adc_nids;
 901         spec->capsrc_nids = preset->capsrc_nids;
 902         spec->dig_in_nid = preset->dig_in_nid;
 903
 904         spec->unsol_event = preset->unsol_event;
 905         spec->init_hook = preset->init_hook;
 906 #ifdef CONFIG_SND_HDA_POWER_SAVE
 907         spec->power_hook = preset->power_hook;
 908         spec->loopback.amplist = preset->loopbacks;
 909 #endif
 910
 911         if (preset->setup)
 912                 preset->setup(codec);
 913 }
 914
 915 /* Enable GPIO mask and set output */
 916 static struct hda_verb alc_gpio1_init_verbs[] = {
 917         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 918         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 919         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 920         { }
 921 };
 922
 923 static struct hda_verb alc_gpio2_init_verbs[] = {
 924         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 925         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 926         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 927         { }
 928 };
 929
 930 static struct hda_verb alc_gpio3_init_verbs[] = {
 931         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 932         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 933         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 934         { }
 935 };
 936
 937 /*
 938  * Fix hardware PLL issue
 939  * On some codecs, the analog PLL gating control must be off while
 940  * the default value is 1.
 941  */
 942 static void alc_fix_pll(struct hda_codec *codec)
 943 {
 944         struct alc_spec *spec = codec->spec;
 945         unsigned int val;
 946
 947         if (!spec->pll_nid)
 948                 return;
 949         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 950                             spec->pll_coef_idx);
 951         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 952                                  AC_VERB_GET_PROC_COEF, 0);
 953         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 954                             spec->pll_coef_idx);
 955         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 956                             val & ~(1 << spec->pll_coef_bit));
 957 }
 958
 959 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 960                              unsigned int coef_idx, unsigned int coef_bit)
 961 {
 962         struct alc_spec *spec = codec->spec;
 963         spec->pll_nid = nid;
 964         spec->pll_coef_idx = coef_idx;
 965         spec->pll_coef_bit = coef_bit;
 966         alc_fix_pll(codec);
 967 }
 968
 969 static void alc_automute_pin(struct hda_codec *codec)
 970 {
 971         struct alc_spec *spec = codec->spec;
 972         unsigned int nid = spec->autocfg.hp_pins[0];
 973         int i;
 974
 975         if (!nid)
 976                 return;
 977         spec->jack_present = snd_hda_jack_detect(codec, nid);
 978         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 979                 nid = spec->autocfg.speaker_pins[i];
 980                 if (!nid)
 981                         break;
 982                 snd_hda_codec_write(codec, nid, 0,
 983                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 984                                     spec->jack_present ? 0 : PIN_OUT);
 985         }
 986 }
 987
 988 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 989                                 hda_nid_t nid)
 990 {
 991         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 992         int i, nums;
 993
 994         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 995         for (i = 0; i < nums; i++)
 996                 if (conn[i] == nid)
 997                         return i;
 998         return -1;
 999 }
1000
1001 static void alc_mic_automute(struct hda_codec *codec)
1002 {
1003         struct alc_spec *spec = codec->spec;
1004         struct alc_mic_route *dead, *alive;
1005         unsigned int present, type;
1006         hda_nid_t cap_nid;
1007
1008         if (!spec->auto_mic)
1009                 return;
1010         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1011                 return;
1012         if (snd_BUG_ON(!spec->adc_nids))
1013                 return;
1014
1015         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1016
1017         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1018         if (present) {
1019                 alive = &spec->ext_mic;
1020                 dead = &spec->int_mic;
1021         } else {
1022                 alive = &spec->int_mic;
1023                 dead = &spec->ext_mic;
1024         }
1025
1026         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1027         if (type == AC_WID_AUD_MIX) {
1028                 /* Matrix-mixer style (e.g. ALC882) */
1029                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1030                                          alive->mux_idx,
1031                                          HDA_AMP_MUTE, 0);
1032                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1033                                          dead->mux_idx,
1034                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1035         } else {
1036                 /* MUX style (e.g. ALC880) */
1037                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1038                                           AC_VERB_SET_CONNECT_SEL,
1039                                           alive->mux_idx);
1040         }
1041
1042         /* FIXME: analog mixer */
1043 }
1044
1045 /* unsolicited event for HP jack sensing */
1046 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1047 {
1048         if (codec->vendor_id == 0x10ec0880)
1049                 res >>= 28;
1050         else
1051                 res >>= 26;
1052         switch (res) {
1053         case ALC880_HP_EVENT:
1054                 alc_automute_pin(codec);
1055                 break;
1056         case ALC880_MIC_EVENT:
1057                 alc_mic_automute(codec);
1058                 break;
1059         }
1060 }
1061
1062 static void alc_inithook(struct hda_codec *codec)
1063 {
1064         alc_automute_pin(codec);
1065         alc_mic_automute(codec);
1066 }
1067
1068 /* additional initialization for ALC888 variants */
1069 static void alc888_coef_init(struct hda_codec *codec)
1070 {
1071         unsigned int tmp;
1072
1073         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1074         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1075         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1076         if ((tmp & 0xf0) == 0x20)
1077                 /* alc888S-VC */
1078                 snd_hda_codec_read(codec, 0x20, 0,
1079                                    AC_VERB_SET_PROC_COEF, 0x830);
1080          else
1081                  /* alc888-VB */
1082                  snd_hda_codec_read(codec, 0x20, 0,
1083                                     AC_VERB_SET_PROC_COEF, 0x3030);
1084 }
1085
1086 static void alc889_coef_init(struct hda_codec *codec)
1087 {
1088         unsigned int tmp;
1089
1090         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1091         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1092         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1093         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1094 }
1095
1096 /* turn on/off EAPD control (only if available) */
1097 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1098 {
1099         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1100                 return;
1101         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1102                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1103                                     on ? 2 : 0);
1104 }
1105
1106 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1107 {
1108         unsigned int tmp;
1109
1110         switch (type) {
1111         case ALC_INIT_GPIO1:
1112                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1113                 break;
1114         case ALC_INIT_GPIO2:
1115                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1116                 break;
1117         case ALC_INIT_GPIO3:
1118                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1119                 break;
1120         case ALC_INIT_DEFAULT:
1121                 switch (codec->vendor_id) {
1122                 case 0x10ec0260:
1123                         set_eapd(codec, 0x0f, 1);
1124                         set_eapd(codec, 0x10, 1);
1125                         break;
1126                 case 0x10ec0262:
1127                 case 0x10ec0267:
1128                 case 0x10ec0268:
1129                 case 0x10ec0269:
1130                 case 0x10ec0270:
1131                 case 0x10ec0272:
1132                 case 0x10ec0660:
1133                 case 0x10ec0662:
1134                 case 0x10ec0663:
1135                 case 0x10ec0862:
1136                 case 0x10ec0889:
1137                         set_eapd(codec, 0x14, 1);
1138                         set_eapd(codec, 0x15, 1);
1139                         break;
1140                 }
1141                 switch (codec->vendor_id) {
1142                 case 0x10ec0260:
1143                         snd_hda_codec_write(codec, 0x1a, 0,
1144                                             AC_VERB_SET_COEF_INDEX, 7);
1145                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1146                                                  AC_VERB_GET_PROC_COEF, 0);
1147                         snd_hda_codec_write(codec, 0x1a, 0,
1148                                             AC_VERB_SET_COEF_INDEX, 7);
1149                         snd_hda_codec_write(codec, 0x1a, 0,
1150                                             AC_VERB_SET_PROC_COEF,
1151                                             tmp | 0x2010);
1152                         break;
1153                 case 0x10ec0262:
1154                 case 0x10ec0880:
1155                 case 0x10ec0882:
1156                 case 0x10ec0883:
1157                 case 0x10ec0885:
1158                 case 0x10ec0887:
1159                 case 0x10ec0889:
1160                         alc889_coef_init(codec);
1161                         break;
1162                 case 0x10ec0888:
1163                         alc888_coef_init(codec);
1164                         break;
1165                 case 0x10ec0267:
1166                 case 0x10ec0268:
1167                         snd_hda_codec_write(codec, 0x20, 0,
1168                                             AC_VERB_SET_COEF_INDEX, 7);
1169                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1170                                                  AC_VERB_GET_PROC_COEF, 0);
1171                         snd_hda_codec_write(codec, 0x20, 0,
1172                                             AC_VERB_SET_COEF_INDEX, 7);
1173                         snd_hda_codec_write(codec, 0x20, 0,
1174                                             AC_VERB_SET_PROC_COEF,
1175                                             tmp | 0x3000);
1176                         break;
1177                 }
1178                 break;
1179         }
1180 }
1181
1182 static void alc_init_auto_hp(struct hda_codec *codec)
1183 {
1184         struct alc_spec *spec = codec->spec;
1185
1186         if (!spec->autocfg.hp_pins[0])
1187                 return;
1188
1189         if (!spec->autocfg.speaker_pins[0]) {
1190                 if (spec->autocfg.line_out_pins[0] &&
1191                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1192                         spec->autocfg.speaker_pins[0] =
1193                                 spec->autocfg.line_out_pins[0];
1194                 else
1195                         return;
1196         }
1197
1198         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1199                     spec->autocfg.hp_pins[0]);
1200         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1201                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1202                                   AC_USRSP_EN | ALC880_HP_EVENT);
1203         spec->unsol_event = alc_sku_unsol_event;
1204 }
1205
1206 static void alc_init_auto_mic(struct hda_codec *codec)
1207 {
1208         struct alc_spec *spec = codec->spec;
1209         struct auto_pin_cfg *cfg = &spec->autocfg;
1210         hda_nid_t fixed, ext;
1211         int i;
1212
1213         /* there must be only two mic inputs exclusively */
1214         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1215                 if (cfg->input_pins[i])
1216                         return;
1217
1218         fixed = ext = 0;
1219         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1220                 hda_nid_t nid = cfg->input_pins[i];
1221                 unsigned int defcfg;
1222                 if (!nid)
1223                         return;
1224                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1225                 switch (get_defcfg_connect(defcfg)) {
1226                 case AC_JACK_PORT_FIXED:
1227                         if (fixed)
1228                                 return; /* already occupied */
1229                         fixed = nid;
1230                         break;
1231                 case AC_JACK_PORT_COMPLEX:
1232                         if (ext)
1233                                 return; /* already occupied */
1234                         ext = nid;
1235                         break;
1236                 default:
1237                         return; /* invalid entry */
1238                 }
1239         }
1240         if (!ext || !fixed)
1241                 return;
1242         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1243                 return; /* no unsol support */
1244         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1245                     ext, fixed);
1246         spec->ext_mic.pin = ext;
1247         spec->int_mic.pin = fixed;
1248         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1249         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1250         spec->auto_mic = 1;
1251         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1252                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1253                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1254         spec->unsol_event = alc_sku_unsol_event;
1255 }
1256
1257 /* check subsystem ID and set up device-specific initialization;
1258  * return 1 if initialized, 0 if invalid SSID
1259  */
1260 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1261  *      31 ~ 16 :       Manufacture ID
1262  *      15 ~ 8  :       SKU ID
1263  *      7  ~ 0  :       Assembly ID
1264  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1265  */
1266 static int alc_subsystem_id(struct hda_codec *codec,
1267                             hda_nid_t porta, hda_nid_t porte,
1268                             hda_nid_t portd)
1269 {
1270         unsigned int ass, tmp, i;
1271         unsigned nid;
1272         struct alc_spec *spec = codec->spec;
1273
1274         ass = codec->subsystem_id & 0xffff;
1275         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1276                 goto do_sku;
1277
1278         /* invalid SSID, check the special NID pin defcfg instead */
1279         /*
1280          * 31~30        : port connectivity
1281          * 29~21        : reserve
1282          * 20           : PCBEEP input
1283          * 19~16        : Check sum (15:1)
1284          * 15~1         : Custom
1285          * 0            : override
1286         */
1287         nid = 0x1d;
1288         if (codec->vendor_id == 0x10ec0260)
1289                 nid = 0x17;
1290         ass = snd_hda_codec_get_pincfg(codec, nid);
1291         snd_printd("realtek: No valid SSID, "
1292                    "checking pincfg 0x%08x for NID 0x%x\n",
1293                    ass, nid);
1294         if (!(ass & 1) && !(ass & 0x100000))
1295                 return 0;
1296         if ((ass >> 30) != 1)   /* no physical connection */
1297                 return 0;
1298
1299         /* check sum */
1300         tmp = 0;
1301         for (i = 1; i < 16; i++) {
1302                 if ((ass >> i) & 1)
1303                         tmp++;
1304         }
1305         if (((ass >> 16) & 0xf) != tmp)
1306                 return 0;
1307 do_sku:
1308         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1309                    ass & 0xffff, codec->vendor_id);
1310         /*
1311          * 0 : override
1312          * 1 :  Swap Jack
1313          * 2 : 0 --> Desktop, 1 --> Laptop
1314          * 3~5 : External Amplifier control
1315          * 7~6 : Reserved
1316         */
1317         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1318         switch (tmp) {
1319         case 1:
1320                 spec->init_amp = ALC_INIT_GPIO1;
1321                 break;
1322         case 3:
1323                 spec->init_amp = ALC_INIT_GPIO2;
1324                 break;
1325         case 7:
1326                 spec->init_amp = ALC_INIT_GPIO3;
1327                 break;
1328         case 5:
1329                 spec->init_amp = ALC_INIT_DEFAULT;
1330                 break;
1331         }
1332
1333         /* is laptop or Desktop and enable the function "Mute internal speaker
1334          * when the external headphone out jack is plugged"
1335          */
1336         if (!(ass & 0x8000))
1337                 return 1;
1338         /*
1339          * 10~8 : Jack location
1340          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1341          * 14~13: Resvered
1342          * 15   : 1 --> enable the function "Mute internal speaker
1343          *              when the external headphone out jack is plugged"
1344          */
1345         if (!spec->autocfg.hp_pins[0]) {
1346                 hda_nid_t nid;
1347                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1348                 if (tmp == 0)
1349                         nid = porta;
1350                 else if (tmp == 1)
1351                         nid = porte;
1352                 else if (tmp == 2)
1353                         nid = portd;
1354                 else
1355                         return 1;
1356                 for (i = 0; i < spec->autocfg.line_outs; i++)
1357                         if (spec->autocfg.line_out_pins[i] == nid)
1358                                 return 1;
1359                 spec->autocfg.hp_pins[0] = nid;
1360         }
1361
1362         alc_init_auto_hp(codec);
1363         alc_init_auto_mic(codec);
1364         return 1;
1365 }
1366
1367 static void alc_ssid_check(struct hda_codec *codec,
1368                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1369 {
1370         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1371                 struct alc_spec *spec = codec->spec;
1372                 snd_printd("realtek: "
1373                            "Enable default setup for auto mode as fallback\n");
1374                 spec->init_amp = ALC_INIT_DEFAULT;
1375                 alc_init_auto_hp(codec);
1376                 alc_init_auto_mic(codec);
1377         }
1378 }
1379
1380 /*
1381  * Fix-up pin default configurations and add default verbs
1382  */
1383
1384 struct alc_pincfg {
1385         hda_nid_t nid;
1386         u32 val;
1387 };
1388
1389 struct alc_fixup {
1390         const struct alc_pincfg *pins;
1391         const struct hda_verb *verbs;
1392 };
1393
1394 static void alc_pick_fixup(struct hda_codec *codec,
1395                            const struct snd_pci_quirk *quirk,
1396                            const struct alc_fixup *fix)
1397 {
1398         const struct alc_pincfg *cfg;
1399
1400         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1401         if (!quirk)
1402                 return;
1403
1404         fix += quirk->value;
1405         cfg = fix->pins;
1406         if (cfg) {
1407                 for (; cfg->nid; cfg++)
1408                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1409         }
1410         if (fix->verbs)
1411                 add_verb(codec->spec, fix->verbs);
1412 }
1413
1414 static int alc_read_coef_idx(struct hda_codec *codec,
1415                         unsigned int coef_idx)
1416 {
1417         unsigned int val;
1418         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1419                                 coef_idx);
1420         val = snd_hda_codec_read(codec, 0x20, 0,
1421                                 AC_VERB_GET_PROC_COEF, 0);
1422         return val;
1423 }
1424
1425 /*
1426  * ALC888
1427  */
1428
1429 /*
1430  * 2ch mode
1431  */
1432 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1433 /* Mic-in jack as mic in */
1434         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1435         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1436 /* Line-in jack as Line in */
1437         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1438         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1439 /* Line-Out as Front */
1440         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1441         { } /* end */
1442 };
1443
1444 /*
1445  * 4ch mode
1446  */
1447 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1448 /* Mic-in jack as mic in */
1449         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1450         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1451 /* Line-in jack as Surround */
1452         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1453         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1454 /* Line-Out as Front */
1455         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1456         { } /* end */
1457 };
1458
1459 /*
1460  * 6ch mode
1461  */
1462 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1463 /* Mic-in jack as CLFE */
1464         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1465         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1466 /* Line-in jack as Surround */
1467         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1468         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1469 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1470         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1471         { } /* end */
1472 };
1473
1474 /*
1475  * 8ch mode
1476  */
1477 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1478 /* Mic-in jack as CLFE */
1479         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1480         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1481 /* Line-in jack as Surround */
1482         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1483         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1484 /* Line-Out as Side */
1485         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1486         { } /* end */
1487 };
1488
1489 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1490         { 2, alc888_4ST_ch2_intel_init },
1491         { 4, alc888_4ST_ch4_intel_init },
1492         { 6, alc888_4ST_ch6_intel_init },
1493         { 8, alc888_4ST_ch8_intel_init },
1494 };
1495
1496 /*
1497  * ALC888 Fujitsu Siemens Amillo xa3530
1498  */
1499
1500 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1501 /* Front Mic: set to PIN_IN (empty by default) */
1502         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1503 /* Connect Internal HP to Front */
1504         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1505         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1506         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1507 /* Connect Bass HP to Front */
1508         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1509         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1510         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1511 /* Connect Line-Out side jack (SPDIF) to Side */
1512         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1513         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1514         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1515 /* Connect Mic jack to CLFE */
1516         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1517         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1518         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1519 /* Connect Line-in jack to Surround */
1520         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1521         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1522         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1523 /* Connect HP out jack to Front */
1524         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1525         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1526         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1527 /* Enable unsolicited event for HP jack and Line-out jack */
1528         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1529         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1530         {}
1531 };
1532
1533 static void alc_automute_amp(struct hda_codec *codec)
1534 {
1535         struct alc_spec *spec = codec->spec;
1536         unsigned int mute;
1537         hda_nid_t nid;
1538         int i;
1539
1540         spec->jack_present = 0;
1541         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1542                 nid = spec->autocfg.hp_pins[i];
1543                 if (!nid)
1544                         break;
1545                 if (snd_hda_jack_detect(codec, nid)) {
1546                         spec->jack_present = 1;
1547                         break;
1548                 }
1549         }
1550
1551         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1552         /* Toggle internal speakers muting */
1553         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1554                 nid = spec->autocfg.speaker_pins[i];
1555                 if (!nid)
1556                         break;
1557                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1558                                          HDA_AMP_MUTE, mute);
1559         }
1560 }
1561
1562 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1563                                          unsigned int res)
1564 {
1565         if (codec->vendor_id == 0x10ec0880)
1566                 res >>= 28;
1567         else
1568                 res >>= 26;
1569         if (res == ALC880_HP_EVENT)
1570                 alc_automute_amp(codec);
1571 }
1572
1573 static void alc889_automute_setup(struct hda_codec *codec)
1574 {
1575         struct alc_spec *spec = codec->spec;
1576
1577         spec->autocfg.hp_pins[0] = 0x15;
1578         spec->autocfg.speaker_pins[0] = 0x14;
1579         spec->autocfg.speaker_pins[1] = 0x16;
1580         spec->autocfg.speaker_pins[2] = 0x17;
1581         spec->autocfg.speaker_pins[3] = 0x19;
1582         spec->autocfg.speaker_pins[4] = 0x1a;
1583 }
1584
1585 static void alc889_intel_init_hook(struct hda_codec *codec)
1586 {
1587         alc889_coef_init(codec);
1588         alc_automute_amp(codec);
1589 }
1590
1591 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1592 {
1593         struct alc_spec *spec = codec->spec;
1594
1595         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1596         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1597         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1598         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1599 }
1600
1601 /*
1602  * ALC888 Acer Aspire 4930G model
1603  */
1604
1605 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1606 /* Front Mic: set to PIN_IN (empty by default) */
1607         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1608 /* Unselect Front Mic by default in input mixer 3 */
1609         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1610 /* Enable unsolicited event for HP jack */
1611         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1612 /* Connect Internal HP to front */
1613         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1614         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1615         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1616 /* Connect HP out to front */
1617         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1618         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1619         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1620         { }
1621 };
1622
1623 /*
1624  * ALC888 Acer Aspire 6530G model
1625  */
1626
1627 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1628 /* Bias voltage on for external mic port */
1629         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1630 /* Front Mic: set to PIN_IN (empty by default) */
1631         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1632 /* Unselect Front Mic by default in input mixer 3 */
1633         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1634 /* Enable unsolicited event for HP jack */
1635         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1636 /* Enable speaker output */
1637         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1638         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1639 /* Enable headphone output */
1640         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1641         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1642         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1643         { }
1644 };
1645
1646 /*
1647  * ALC889 Acer Aspire 8930G model
1648  */
1649
1650 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1651 /* Front Mic: set to PIN_IN (empty by default) */
1652         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1653 /* Unselect Front Mic by default in input mixer 3 */
1654         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1655 /* Enable unsolicited event for HP jack */
1656         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1657 /* Connect Internal Front to Front */
1658         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1659         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1660         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1661 /* Connect Internal Rear to Rear */
1662         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1663         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1664         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1665 /* Connect Internal CLFE to CLFE */
1666         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1667         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1668         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1669 /* Connect HP out to Front */
1670         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1671         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1672         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1673 /* Enable all DACs */
1674 /*  DAC DISABLE/MUTE 1? */
1675 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1676         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1677         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1678 /*  DAC DISABLE/MUTE 2? */
1679 /*  some bit here disables the other DACs. Init=0x4900 */
1680         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1681         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1682 /* DMIC fix
1683  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1684  * which makes the stereo useless. However, either the mic or the ALC889
1685  * makes the signal become a difference/sum signal instead of standard
1686  * stereo, which is annoying. So instead we flip this bit which makes the
1687  * codec replicate the sum signal to both channels, turning it into a
1688  * normal mono mic.
1689  */
1690 /*  DMIC_CONTROL? Init value = 0x0001 */
1691         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1692         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1693         { }
1694 };
1695
1696 static struct hda_input_mux alc888_2_capture_sources[2] = {
1697         /* Front mic only available on one ADC */
1698         {
1699                 .num_items = 4,
1700                 .items = {
1701                         { "Mic", 0x0 },
1702                         { "Line", 0x2 },
1703                         { "CD", 0x4 },
1704                         { "Front Mic", 0xb },
1705                 },
1706         },
1707         {
1708                 .num_items = 3,
1709                 .items = {
1710                         { "Mic", 0x0 },
1711                         { "Line", 0x2 },
1712                         { "CD", 0x4 },
1713                 },
1714         }
1715 };
1716
1717 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1718         /* Interal mic only available on one ADC */
1719         {
1720                 .num_items = 5,
1721                 .items = {
1722                         { "Ext Mic", 0x0 },
1723                         { "Line In", 0x2 },
1724                         { "CD", 0x4 },
1725                         { "Input Mix", 0xa },
1726                         { "Int Mic", 0xb },
1727                 },
1728         },
1729         {
1730                 .num_items = 4,
1731                 .items = {
1732                         { "Ext Mic", 0x0 },
1733                         { "Line In", 0x2 },
1734                         { "CD", 0x4 },
1735                         { "Input Mix", 0xa },
1736                 },
1737         }
1738 };
1739
1740 static struct hda_input_mux alc889_capture_sources[3] = {
1741         /* Digital mic only available on first "ADC" */
1742         {
1743                 .num_items = 5,
1744                 .items = {
1745                         { "Mic", 0x0 },
1746                         { "Line", 0x2 },
1747                         { "CD", 0x4 },
1748                         { "Front Mic", 0xb },
1749                         { "Input Mix", 0xa },
1750                 },
1751         },
1752         {
1753                 .num_items = 4,
1754                 .items = {
1755                         { "Mic", 0x0 },
1756                         { "Line", 0x2 },
1757                         { "CD", 0x4 },
1758                         { "Input Mix", 0xa },
1759                 },
1760         },
1761         {
1762                 .num_items = 4,
1763                 .items = {
1764                         { "Mic", 0x0 },
1765                         { "Line", 0x2 },
1766                         { "CD", 0x4 },
1767                         { "Input Mix", 0xa },
1768                 },
1769         }
1770 };
1771
1772 static struct snd_kcontrol_new alc888_base_mixer[] = {
1773         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1774         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1775         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1776         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1777         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1778                 HDA_OUTPUT),
1779         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1780         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1781         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1782         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1783         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1784         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1785         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1786         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1787         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1788         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1789         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1790         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1791         { } /* end */
1792 };
1793
1794 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1795         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1796         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1797         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1798         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1799         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1800                 HDA_OUTPUT),
1801         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1802         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1803         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1804         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1805         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1806         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1807         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1808         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1809         { } /* end */
1810 };
1811
1812
1813 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1814 {
1815         struct alc_spec *spec = codec->spec;
1816
1817         spec->autocfg.hp_pins[0] = 0x15;
1818         spec->autocfg.speaker_pins[0] = 0x14;
1819         spec->autocfg.speaker_pins[1] = 0x16;
1820         spec->autocfg.speaker_pins[2] = 0x17;
1821 }
1822
1823 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1824 {
1825         struct alc_spec *spec = codec->spec;
1826
1827         spec->autocfg.hp_pins[0] = 0x15;
1828         spec->autocfg.speaker_pins[0] = 0x14;
1829         spec->autocfg.speaker_pins[1] = 0x16;
1830         spec->autocfg.speaker_pins[2] = 0x17;
1831 }
1832
1833 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1834 {
1835         struct alc_spec *spec = codec->spec;
1836
1837         spec->autocfg.hp_pins[0] = 0x15;
1838         spec->autocfg.speaker_pins[0] = 0x14;
1839         spec->autocfg.speaker_pins[1] = 0x16;
1840         spec->autocfg.speaker_pins[2] = 0x1b;
1841 }
1842
1843 #ifdef CONFIG_SND_HDA_POWER_SAVE
1844 static void alc889_power_eapd(struct hda_codec *codec, int power)
1845 {
1846         set_eapd(codec, 0x14, power);
1847         set_eapd(codec, 0x15, power);
1848 }
1849 #endif
1850
1851 /*
1852  * ALC880 3-stack model
1853  *
1854  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1855  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1856  *                 F-Mic = 0x1b, HP = 0x19
1857  */
1858
1859 static hda_nid_t alc880_dac_nids[4] = {
1860         /* front, rear, clfe, rear_surr */
1861         0x02, 0x05, 0x04, 0x03
1862 };
1863
1864 static hda_nid_t alc880_adc_nids[3] = {
1865         /* ADC0-2 */
1866         0x07, 0x08, 0x09,
1867 };
1868
1869 /* The datasheet says the node 0x07 is connected from inputs,
1870  * but it shows zero connection in the real implementation on some devices.
1871  * Note: this is a 915GAV bug, fixed on 915GLV
1872  */
1873 static hda_nid_t alc880_adc_nids_alt[2] = {
1874         /* ADC1-2 */
1875         0x08, 0x09,
1876 };
1877
1878 #define ALC880_DIGOUT_NID       0x06
1879 #define ALC880_DIGIN_NID        0x0a
1880
1881 static struct hda_input_mux alc880_capture_source = {
1882         .num_items = 4,
1883         .items = {
1884                 { "Mic", 0x0 },
1885                 { "Front Mic", 0x3 },
1886                 { "Line", 0x2 },
1887                 { "CD", 0x4 },
1888         },
1889 };
1890
1891 /* channel source setting (2/6 channel selection for 3-stack) */
1892 /* 2ch mode */
1893 static struct hda_verb alc880_threestack_ch2_init[] = {
1894         /* set line-in to input, mute it */
1895         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1896         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1897         /* set mic-in to input vref 80%, mute it */
1898         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1899         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1900         { } /* end */
1901 };
1902
1903 /* 6ch mode */
1904 static struct hda_verb alc880_threestack_ch6_init[] = {
1905         /* set line-in to output, unmute it */
1906         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1907         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1908         /* set mic-in to output, unmute it */
1909         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1910         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1911         { } /* end */
1912 };
1913
1914 static struct hda_channel_mode alc880_threestack_modes[2] = {
1915         { 2, alc880_threestack_ch2_init },
1916         { 6, alc880_threestack_ch6_init },
1917 };
1918
1919 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1920         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1921         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1922         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1923         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1924         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1925         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1926         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1927         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1928         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1929         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1930         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1931         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1932         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1933         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1934         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1935         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1936         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1937         {
1938                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1939                 .name = "Channel Mode",
1940                 .info = alc_ch_mode_info,
1941                 .get = alc_ch_mode_get,
1942                 .put = alc_ch_mode_put,
1943         },
1944         { } /* end */
1945 };
1946
1947 /* capture mixer elements */
1948 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1949                             struct snd_ctl_elem_info *uinfo)
1950 {
1951         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1952         struct alc_spec *spec = codec->spec;
1953         int err;
1954
1955         mutex_lock(&codec->control_mutex);
1956         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1957                                                       HDA_INPUT);
1958         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1959         mutex_unlock(&codec->control_mutex);
1960         return err;
1961 }
1962
1963 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1964                            unsigned int size, unsigned int __user *tlv)
1965 {
1966         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1967         struct alc_spec *spec = codec->spec;
1968         int err;
1969
1970         mutex_lock(&codec->control_mutex);
1971         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1972                                                       HDA_INPUT);
1973         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1974         mutex_unlock(&codec->control_mutex);
1975         return err;
1976 }
1977
1978 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1979                              struct snd_ctl_elem_value *ucontrol);
1980
1981 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1982                                  struct snd_ctl_elem_value *ucontrol,
1983                                  getput_call_t func)
1984 {
1985         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1986         struct alc_spec *spec = codec->spec;
1987         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1988         int err;
1989
1990         mutex_lock(&codec->control_mutex);
1991         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1992                                                       3, 0, HDA_INPUT);
1993         err = func(kcontrol, ucontrol);
1994         mutex_unlock(&codec->control_mutex);
1995         return err;
1996 }
1997
1998 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1999                            struct snd_ctl_elem_value *ucontrol)
2000 {
2001         return alc_cap_getput_caller(kcontrol, ucontrol,
2002                                      snd_hda_mixer_amp_volume_get);
2003 }
2004
2005 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2006                            struct snd_ctl_elem_value *ucontrol)
2007 {
2008         return alc_cap_getput_caller(kcontrol, ucontrol,
2009                                      snd_hda_mixer_amp_volume_put);
2010 }
2011
2012 /* capture mixer elements */
2013 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2014
2015 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2016                           struct snd_ctl_elem_value *ucontrol)
2017 {
2018         return alc_cap_getput_caller(kcontrol, ucontrol,
2019                                      snd_hda_mixer_amp_switch_get);
2020 }
2021
2022 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2023                           struct snd_ctl_elem_value *ucontrol)
2024 {
2025         return alc_cap_getput_caller(kcontrol, ucontrol,
2026                                      snd_hda_mixer_amp_switch_put);
2027 }
2028
2029 #define _DEFINE_CAPMIX(num) \
2030         { \
2031                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2032                 .name = "Capture Switch", \
2033                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2034                 .count = num, \
2035                 .info = alc_cap_sw_info, \
2036                 .get = alc_cap_sw_get, \
2037                 .put = alc_cap_sw_put, \
2038         }, \
2039         { \
2040                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2041                 .name = "Capture Volume", \
2042                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2043                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2044                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2045                 .count = num, \
2046                 .info = alc_cap_vol_info, \
2047                 .get = alc_cap_vol_get, \
2048                 .put = alc_cap_vol_put, \
2049                 .tlv = { .c = alc_cap_vol_tlv }, \
2050         }
2051
2052 #define _DEFINE_CAPSRC(num) \
2053         { \
2054                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2055                 /* .name = "Capture Source", */ \
2056                 .name = "Input Source", \
2057                 .count = num, \
2058                 .info = alc_mux_enum_info, \
2059                 .get = alc_mux_enum_get, \
2060                 .put = alc_mux_enum_put, \
2061         }
2062
2063 #define DEFINE_CAPMIX(num) \
2064 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2065         _DEFINE_CAPMIX(num),                                  \
2066         _DEFINE_CAPSRC(num),                                  \
2067         { } /* end */                                         \
2068 }
2069
2070 #define DEFINE_CAPMIX_NOSRC(num) \
2071 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2072         _DEFINE_CAPMIX(num),                                        \
2073         { } /* end */                                               \
2074 }
2075
2076 /* up to three ADCs */
2077 DEFINE_CAPMIX(1);
2078 DEFINE_CAPMIX(2);
2079 DEFINE_CAPMIX(3);
2080 DEFINE_CAPMIX_NOSRC(1);
2081 DEFINE_CAPMIX_NOSRC(2);
2082 DEFINE_CAPMIX_NOSRC(3);
2083
2084 /*
2085  * ALC880 5-stack model
2086  *
2087  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2088  *      Side = 0x02 (0xd)
2089  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2090  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2091  */
2092
2093 /* additional mixers to alc880_three_stack_mixer */
2094 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2095         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2096         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2097         { } /* end */
2098 };
2099
2100 /* channel source setting (6/8 channel selection for 5-stack) */
2101 /* 6ch mode */
2102 static struct hda_verb alc880_fivestack_ch6_init[] = {
2103         /* set line-in to input, mute it */
2104         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2105         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2106         { } /* end */
2107 };
2108
2109 /* 8ch mode */
2110 static struct hda_verb alc880_fivestack_ch8_init[] = {
2111         /* set line-in to output, unmute it */
2112         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2113         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2114         { } /* end */
2115 };
2116
2117 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2118         { 6, alc880_fivestack_ch6_init },
2119         { 8, alc880_fivestack_ch8_init },
2120 };
2121
2122
2123 /*
2124  * ALC880 6-stack model
2125  *
2126  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2127  *      Side = 0x05 (0x0f)
2128  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2129  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2130  */
2131
2132 static hda_nid_t alc880_6st_dac_nids[4] = {
2133         /* front, rear, clfe, rear_surr */
2134         0x02, 0x03, 0x04, 0x05
2135 };
2136
2137 static struct hda_input_mux alc880_6stack_capture_source = {
2138         .num_items = 4,
2139         .items = {
2140                 { "Mic", 0x0 },
2141                 { "Front Mic", 0x1 },
2142                 { "Line", 0x2 },
2143                 { "CD", 0x4 },
2144         },
2145 };
2146
2147 /* fixed 8-channels */
2148 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2149         { 8, NULL },
2150 };
2151
2152 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2153         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2154         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2155         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2156         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2157         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2158         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2159         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2160         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2161         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2162         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2163         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2164         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2165         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2166         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2167         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2168         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2169         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2170         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2171         {
2172                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2173                 .name = "Channel Mode",
2174                 .info = alc_ch_mode_info,
2175                 .get = alc_ch_mode_get,
2176                 .put = alc_ch_mode_put,
2177         },
2178         { } /* end */
2179 };
2180
2181
2182 /*
2183  * ALC880 W810 model
2184  *
2185  * W810 has rear IO for:
2186  * Front (DAC 02)
2187  * Surround (DAC 03)
2188  * Center/LFE (DAC 04)
2189  * Digital out (06)
2190  *
2191  * The system also has a pair of internal speakers, and a headphone jack.
2192  * These are both connected to Line2 on the codec, hence to DAC 02.
2193  *
2194  * There is a variable resistor to control the speaker or headphone
2195  * volume. This is a hardware-only device without a software API.
2196  *
2197  * Plugging headphones in will disable the internal speakers. This is
2198  * implemented in hardware, not via the driver using jack sense. In
2199  * a similar fashion, plugging into the rear socket marked "front" will
2200  * disable both the speakers and headphones.
2201  *
2202  * For input, there's a microphone jack, and an "audio in" jack.
2203  * These may not do anything useful with this driver yet, because I
2204  * haven't setup any initialization verbs for these yet...
2205  */
2206
2207 static hda_nid_t alc880_w810_dac_nids[3] = {
2208         /* front, rear/surround, clfe */
2209         0x02, 0x03, 0x04
2210 };
2211
2212 /* fixed 6 channels */
2213 static struct hda_channel_mode alc880_w810_modes[1] = {
2214         { 6, NULL }
2215 };
2216
2217 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2218 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2219         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2220         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2221         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2222         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2223         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2224         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2225         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2226         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2227         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2228         { } /* end */
2229 };
2230
2231
2232 /*
2233  * Z710V model
2234  *
2235  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2236  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2237  *                 Line = 0x1a
2238  */
2239
2240 static hda_nid_t alc880_z71v_dac_nids[1] = {
2241         0x02
2242 };
2243 #define ALC880_Z71V_HP_DAC      0x03
2244
2245 /* fixed 2 channels */
2246 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2247         { 2, NULL }
2248 };
2249
2250 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2251         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2252         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2253         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2254         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2255         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2256         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2257         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2258         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2259         { } /* end */
2260 };
2261
2262
2263 /*
2264  * ALC880 F1734 model
2265  *
2266  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2267  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2268  */
2269
2270 static hda_nid_t alc880_f1734_dac_nids[1] = {
2271         0x03
2272 };
2273 #define ALC880_F1734_HP_DAC     0x02
2274
2275 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2276         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2277         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2278         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2279         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2280         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2281         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2282         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2283         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2284         { } /* end */
2285 };
2286
2287 static struct hda_input_mux alc880_f1734_capture_source = {
2288         .num_items = 2,
2289         .items = {
2290                 { "Mic", 0x1 },
2291                 { "CD", 0x4 },
2292         },
2293 };
2294
2295
2296 /*
2297  * ALC880 ASUS model
2298  *
2299  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2300  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2301  *  Mic = 0x18, Line = 0x1a
2302  */
2303
2304 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2305 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2306
2307 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2308         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2309         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2310         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2311         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2312         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2313         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2314         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2315         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2316         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2317         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2318         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2319         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2320         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2321         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2322         {
2323                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2324                 .name = "Channel Mode",
2325                 .info = alc_ch_mode_info,
2326                 .get = alc_ch_mode_get,
2327                 .put = alc_ch_mode_put,
2328         },
2329         { } /* end */
2330 };
2331
2332 /*
2333  * ALC880 ASUS W1V model
2334  *
2335  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2336  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2337  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2338  */
2339
2340 /* additional mixers to alc880_asus_mixer */
2341 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2342         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2343         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2344         { } /* end */
2345 };
2346
2347 /* TCL S700 */
2348 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2349         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2350         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2351         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2352         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2353         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2354         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2355         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2356         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2357         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2358         { } /* end */
2359 };
2360
2361 /* Uniwill */
2362 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2363         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2364         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2365         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2366         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2367         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2368         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2369         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2370         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2371         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2372         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2373         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2374         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2375         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2376         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2377         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2378         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2379         {
2380                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2381                 .name = "Channel Mode",
2382                 .info = alc_ch_mode_info,
2383                 .get = alc_ch_mode_get,
2384                 .put = alc_ch_mode_put,
2385         },
2386         { } /* end */
2387 };
2388
2389 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2390         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2391         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2392         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2393         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2394         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2395         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2396         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2397         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2398         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2399         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2400         { } /* end */
2401 };
2402
2403 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2404         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2405         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2406         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2407         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2408         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2409         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2410         { } /* end */
2411 };
2412
2413 /*
2414  * virtual master controls
2415  */
2416
2417 /*
2418  * slave controls for virtual master
2419  */
2420 static const char *alc_slave_vols[] = {
2421         "Front Playback Volume",
2422         "Surround Playback Volume",
2423         "Center Playback Volume",
2424         "LFE Playback Volume",
2425         "Side Playback Volume",
2426         "Headphone Playback Volume",
2427         "Speaker Playback Volume",
2428         "Mono Playback Volume",
2429         "Line-Out Playback Volume",
2430         "PCM Playback Volume",
2431         NULL,
2432 };
2433
2434 static const char *alc_slave_sws[] = {
2435         "Front Playback Switch",
2436         "Surround Playback Switch",
2437         "Center Playback Switch",
2438         "LFE Playback Switch",
2439         "Side Playback Switch",
2440         "Headphone Playback Switch",
2441         "Speaker Playback Switch",
2442         "Mono Playback Switch",
2443         "IEC958 Playback Switch",
2444         "Line-Out Playback Switch",
2445         "PCM Playback Switch",
2446         NULL,
2447 };
2448
2449 /*
2450  * build control elements
2451  */
2452
2453 static void alc_free_kctls(struct hda_codec *codec);
2454
2455 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2456 /* additional beep mixers; the actual parameters are overwritten at build */
2457 static struct snd_kcontrol_new alc_beep_mixer[] = {
2458         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2459         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2460         { } /* end */
2461 };
2462 #endif
2463
2464 static int alc_build_controls(struct hda_codec *codec)
2465 {
2466         struct alc_spec *spec = codec->spec;
2467         int err;
2468         int i;
2469
2470         for (i = 0; i < spec->num_mixers; i++) {
2471                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2472                 if (err < 0)
2473                         return err;
2474         }
2475         if (spec->cap_mixer) {
2476                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2477                 if (err < 0)
2478                         return err;
2479         }
2480         if (spec->multiout.dig_out_nid) {
2481                 err = snd_hda_create_spdif_out_ctls(codec,
2482                                                     spec->multiout.dig_out_nid);
2483                 if (err < 0)
2484                         return err;
2485                 if (!spec->no_analog) {
2486                         err = snd_hda_create_spdif_share_sw(codec,
2487                                                             &spec->multiout);
2488                         if (err < 0)
2489                                 return err;
2490                         spec->multiout.share_spdif = 1;
2491                 }
2492         }
2493         if (spec->dig_in_nid) {
2494                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2495                 if (err < 0)
2496                         return err;
2497         }
2498
2499 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2500         /* create beep controls if needed */
2501         if (spec->beep_amp) {
2502                 struct snd_kcontrol_new *knew;
2503                 for (knew = alc_beep_mixer; knew->name; knew++) {
2504                         struct snd_kcontrol *kctl;
2505                         kctl = snd_ctl_new1(knew, codec);
2506                         if (!kctl)
2507                                 return -ENOMEM;
2508                         kctl->private_value = spec->beep_amp;
2509                         err = snd_hda_ctl_add(codec,
2510                                         get_amp_nid_(spec->beep_amp), kctl);
2511                         if (err < 0)
2512                                 return err;
2513                 }
2514         }
2515 #endif
2516
2517         /* if we have no master control, let's create it */
2518         if (!spec->no_analog &&
2519             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2520                 unsigned int vmaster_tlv[4];
2521                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2522                                         HDA_OUTPUT, vmaster_tlv);
2523                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2524                                           vmaster_tlv, alc_slave_vols);
2525                 if (err < 0)
2526                         return err;
2527         }
2528         if (!spec->no_analog &&
2529             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2530                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2531                                           NULL, alc_slave_sws);
2532                 if (err < 0)
2533                         return err;
2534         }
2535
2536         alc_free_kctls(codec); /* no longer needed */
2537         return 0;
2538 }
2539
2540
2541 /*
2542  * initialize the codec volumes, etc
2543  */
2544
2545 /*
2546  * generic initialization of ADC, input mixers and output mixers
2547  */
2548 static struct hda_verb alc880_volume_init_verbs[] = {
2549         /*
2550          * Unmute ADC0-2 and set the default input to mic-in
2551          */
2552         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2553         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2554         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2555         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2556         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2557         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2558
2559         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2560          * mixer widget
2561          * Note: PASD motherboards uses the Line In 2 as the input for front
2562          * panel mic (mic 2)
2563          */
2564         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2565         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2566         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2567         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2572
2573         /*
2574          * Set up output mixers (0x0c - 0x0f)
2575          */
2576         /* set vol=0 to output mixers */
2577         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2578         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2579         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2580         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2581         /* set up input amps for analog loopback */
2582         /* Amp Indices: DAC = 0, mixer = 1 */
2583         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2584         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2586         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2587         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2588         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2589         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2590         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2591
2592         { }
2593 };
2594
2595 /*
2596  * 3-stack pin configuration:
2597  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2598  */
2599 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2600         /*
2601          * preset connection lists of input pins
2602          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2603          */
2604         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2605         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2606         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2607
2608         /*
2609          * Set pin mode and muting
2610          */
2611         /* set front pin widgets 0x14 for output */
2612         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2613         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2614         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2615         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2616         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2617         /* Mic2 (as headphone out) for HP output */
2618         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2619         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2620         /* Line In pin widget for input */
2621         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2622         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2623         /* Line2 (as front mic) pin widget for input and vref at 80% */
2624         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2625         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2626         /* CD pin widget for input */
2627         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2628
2629         { }
2630 };
2631
2632 /*
2633  * 5-stack pin configuration:
2634  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2635  * line-in/side = 0x1a, f-mic = 0x1b
2636  */
2637 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2638         /*
2639          * preset connection lists of input pins
2640          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2641          */
2642         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2643         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2644
2645         /*
2646          * Set pin mode and muting
2647          */
2648         /* set pin widgets 0x14-0x17 for output */
2649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2650         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2651         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2652         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2653         /* unmute pins for output (no gain on this amp) */
2654         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2655         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2656         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2657         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2658
2659         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2660         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2661         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2662         /* Mic2 (as headphone out) for HP output */
2663         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2664         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2665         /* Line In pin widget for input */
2666         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2667         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2668         /* Line2 (as front mic) pin widget for input and vref at 80% */
2669         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2670         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2671         /* CD pin widget for input */
2672         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2673
2674         { }
2675 };
2676
2677 /*
2678  * W810 pin configuration:
2679  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2680  */
2681 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2682         /* hphone/speaker input selector: front DAC */
2683         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2684
2685         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2686         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2687         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2688         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2689         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2690         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2691
2692         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2693         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2694
2695         { }
2696 };
2697
2698 /*
2699  * Z71V pin configuration:
2700  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2701  */
2702 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2703         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2704         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2705         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2706         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2707
2708         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2709         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2710         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2711         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2712
2713         { }
2714 };
2715
2716 /*
2717  * 6-stack pin configuration:
2718  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2719  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2720  */
2721 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2722         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2723
2724         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2725         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2726         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2727         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2728         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2729         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2730         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2731         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2732
2733         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2734         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2735         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2736         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2737         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2738         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2739         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2740         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2741         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2742
2743         { }
2744 };
2745
2746 /*
2747  * Uniwill pin configuration:
2748  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2749  * line = 0x1a
2750  */
2751 static struct hda_verb alc880_uniwill_init_verbs[] = {
2752         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2753
2754         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2755         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2756         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2757         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2758         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2759         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2760         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2761         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2762         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2763         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2764         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2765         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2766         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2767         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2768
2769         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2770         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2771         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2772         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2773         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2774         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2775         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2776         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2777         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2778
2779         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2780         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2781
2782         { }
2783 };
2784
2785 /*
2786 * Uniwill P53
2787 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2788  */
2789 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2790         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2791
2792         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2793         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2794         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2795         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2796         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2797         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2798         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2799         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2800         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2801         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2802         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2803         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2804
2805         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2806         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2807         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2808         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2809         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2810         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2811
2812         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2813         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2814
2815         { }
2816 };
2817
2818 static struct hda_verb alc880_beep_init_verbs[] = {
2819         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2820         { }
2821 };
2822
2823 /* auto-toggle front mic */
2824 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2825 {
2826         unsigned int present;
2827         unsigned char bits;
2828
2829         present = snd_hda_jack_detect(codec, 0x18);
2830         bits = present ? HDA_AMP_MUTE : 0;
2831         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2832 }
2833
2834 static void alc880_uniwill_setup(struct hda_codec *codec)
2835 {
2836         struct alc_spec *spec = codec->spec;
2837
2838         spec->autocfg.hp_pins[0] = 0x14;
2839         spec->autocfg.speaker_pins[0] = 0x15;
2840         spec->autocfg.speaker_pins[0] = 0x16;
2841 }
2842
2843 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2844 {
2845         alc_automute_amp(codec);
2846         alc880_uniwill_mic_automute(codec);
2847 }
2848
2849 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2850                                        unsigned int res)
2851 {
2852         /* Looks like the unsol event is incompatible with the standard
2853          * definition.  4bit tag is placed at 28 bit!
2854          */
2855         switch (res >> 28) {
2856         case ALC880_MIC_EVENT:
2857                 alc880_uniwill_mic_automute(codec);
2858                 break;
2859         default:
2860                 alc_automute_amp_unsol_event(codec, res);
2861                 break;
2862         }
2863 }
2864
2865 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2866 {
2867         struct alc_spec *spec = codec->spec;
2868
2869         spec->autocfg.hp_pins[0] = 0x14;
2870         spec->autocfg.speaker_pins[0] = 0x15;
2871 }
2872
2873 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2874 {
2875         unsigned int present;
2876
2877         present = snd_hda_codec_read(codec, 0x21, 0,
2878                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2879         present &= HDA_AMP_VOLMASK;
2880         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2881                                  HDA_AMP_VOLMASK, present);
2882         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2883                                  HDA_AMP_VOLMASK, present);
2884 }
2885
2886 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2887                                            unsigned int res)
2888 {
2889         /* Looks like the unsol event is incompatible with the standard
2890          * definition.  4bit tag is placed at 28 bit!
2891          */
2892         if ((res >> 28) == ALC880_DCVOL_EVENT)
2893                 alc880_uniwill_p53_dcvol_automute(codec);
2894         else
2895                 alc_automute_amp_unsol_event(codec, res);
2896 }
2897
2898 /*
2899  * F1734 pin configuration:
2900  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2901  */
2902 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2903         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2904         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2905         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2906         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2907         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2908
2909         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2910         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2911         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2912         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2913
2914         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2915         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2916         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2917         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2918         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2919         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2920         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2921         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2922         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2923
2924         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2925         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2926
2927         { }
2928 };
2929
2930 /*
2931  * ASUS pin configuration:
2932  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2933  */
2934 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2935         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2936         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2937         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2938         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2939
2940         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2941         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2942         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2943         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2944         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2945         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2946         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2947         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2948
2949         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2950         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2951         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2952         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2953         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2954         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2955         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2956         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2957         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2958
2959         { }
2960 };
2961
2962 /* Enable GPIO mask and set output */
2963 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2964 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2965 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
2966
2967 /* Clevo m520g init */
2968 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2969         /* headphone output */
2970         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2971         /* line-out */
2972         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2973         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2974         /* Line-in */
2975         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2976         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2977         /* CD */
2978         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2979         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2980         /* Mic1 (rear panel) */
2981         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2982         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2983         /* Mic2 (front panel) */
2984         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2985         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2986         /* headphone */
2987         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2988         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2989         /* change to EAPD mode */
2990         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2991         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2992
2993         { }
2994 };
2995
2996 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2997         /* change to EAPD mode */
2998         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2999         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3000
3001         /* Headphone output */
3002         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3003         /* Front output*/
3004         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3005         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3006
3007         /* Line In pin widget for input */
3008         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3009         /* CD pin widget for input */
3010         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3011         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3012         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3013
3014         /* change to EAPD mode */
3015         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3016         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3017
3018         { }
3019 };
3020
3021 /*
3022  * LG m1 express dual
3023  *
3024  * Pin assignment:
3025  *   Rear Line-In/Out (blue): 0x14
3026  *   Build-in Mic-In: 0x15
3027  *   Speaker-out: 0x17
3028  *   HP-Out (green): 0x1b
3029  *   Mic-In/Out (red): 0x19
3030  *   SPDIF-Out: 0x1e
3031  */
3032
3033 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3034 static hda_nid_t alc880_lg_dac_nids[3] = {
3035         0x05, 0x02, 0x03
3036 };
3037
3038 /* seems analog CD is not working */
3039 static struct hda_input_mux alc880_lg_capture_source = {
3040         .num_items = 3,
3041         .items = {
3042                 { "Mic", 0x1 },
3043                 { "Line", 0x5 },
3044                 { "Internal Mic", 0x6 },
3045         },
3046 };
3047
3048 /* 2,4,6 channel modes */
3049 static struct hda_verb alc880_lg_ch2_init[] = {
3050         /* set line-in and mic-in to input */
3051         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3052         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3053         { }
3054 };
3055
3056 static struct hda_verb alc880_lg_ch4_init[] = {
3057         /* set line-in to out and mic-in to input */
3058         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3059         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3060         { }
3061 };
3062
3063 static struct hda_verb alc880_lg_ch6_init[] = {
3064         /* set line-in and mic-in to output */
3065         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3066         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3067         { }
3068 };
3069
3070 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3071         { 2, alc880_lg_ch2_init },
3072         { 4, alc880_lg_ch4_init },
3073         { 6, alc880_lg_ch6_init },
3074 };
3075
3076 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3077         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3078         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3079         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3080         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3081         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3082         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3083         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3084         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3085         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3086         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3087         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3088         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3089         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3090         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3091         {
3092                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3093                 .name = "Channel Mode",
3094                 .info = alc_ch_mode_info,
3095                 .get = alc_ch_mode_get,
3096                 .put = alc_ch_mode_put,
3097         },
3098         { } /* end */
3099 };
3100
3101 static struct hda_verb alc880_lg_init_verbs[] = {
3102         /* set capture source to mic-in */
3103         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3104         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3105         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3106         /* mute all amp mixer inputs */
3107         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3108         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3109         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3110         /* line-in to input */
3111         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3112         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3113         /* built-in mic */
3114         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3115         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3116         /* speaker-out */
3117         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3118         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3119         /* mic-in to input */
3120         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3121         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3122         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3123         /* HP-out */
3124         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3125         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3126         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3127         /* jack sense */
3128         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3129         { }
3130 };
3131
3132 /* toggle speaker-output according to the hp-jack state */
3133 static void alc880_lg_setup(struct hda_codec *codec)
3134 {
3135         struct alc_spec *spec = codec->spec;
3136
3137         spec->autocfg.hp_pins[0] = 0x1b;
3138         spec->autocfg.speaker_pins[0] = 0x17;
3139 }
3140
3141 /*
3142  * LG LW20
3143  *
3144  * Pin assignment:
3145  *   Speaker-out: 0x14
3146  *   Mic-In: 0x18
3147  *   Built-in Mic-In: 0x19
3148  *   Line-In: 0x1b
3149  *   HP-Out: 0x1a
3150  *   SPDIF-Out: 0x1e
3151  */
3152
3153 static struct hda_input_mux alc880_lg_lw_capture_source = {
3154         .num_items = 3,
3155         .items = {
3156                 { "Mic", 0x0 },
3157                 { "Internal Mic", 0x1 },
3158                 { "Line In", 0x2 },
3159         },
3160 };
3161
3162 #define alc880_lg_lw_modes alc880_threestack_modes
3163
3164 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3165         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3166         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3167         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3168         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3169         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3170         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3171         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3172         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3173         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3174         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3175         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3176         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3177         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3178         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3179         {
3180                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3181                 .name = "Channel Mode",
3182                 .info = alc_ch_mode_info,
3183                 .get = alc_ch_mode_get,
3184                 .put = alc_ch_mode_put,
3185         },
3186         { } /* end */
3187 };
3188
3189 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3190         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3191         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3192         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3193
3194         /* set capture source to mic-in */
3195         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3196         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3197         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3198         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3199         /* speaker-out */
3200         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3201         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3202         /* HP-out */
3203         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3204         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3205         /* mic-in to input */
3206         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3207         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3208         /* built-in mic */
3209         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3210         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3211         /* jack sense */
3212         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3213         { }
3214 };
3215
3216 /* toggle speaker-output according to the hp-jack state */
3217 static void alc880_lg_lw_setup(struct hda_codec *codec)
3218 {
3219         struct alc_spec *spec = codec->spec;
3220
3221         spec->autocfg.hp_pins[0] = 0x1b;
3222         spec->autocfg.speaker_pins[0] = 0x14;
3223 }
3224
3225 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3226         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3227         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3228         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3229         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3230         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3231         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3232         { } /* end */
3233 };
3234
3235 static struct hda_input_mux alc880_medion_rim_capture_source = {
3236         .num_items = 2,
3237         .items = {
3238                 { "Mic", 0x0 },
3239                 { "Internal Mic", 0x1 },
3240         },
3241 };
3242
3243 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3244         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3245
3246         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3247         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3248
3249         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3250         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3251         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3252         /* Mic2 (as headphone out) for HP output */
3253         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3254         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3255         /* Internal Speaker */
3256         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3257         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3258
3259         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3260         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3261
3262         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3263         { }
3264 };
3265
3266 /* toggle speaker-output according to the hp-jack state */
3267 static void alc880_medion_rim_automute(struct hda_codec *codec)
3268 {
3269         struct alc_spec *spec = codec->spec;
3270         alc_automute_amp(codec);
3271         /* toggle EAPD */
3272         if (spec->jack_present)
3273                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3274         else
3275                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3276 }
3277
3278 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3279                                           unsigned int res)
3280 {
3281         /* Looks like the unsol event is incompatible with the standard
3282          * definition.  4bit tag is placed at 28 bit!
3283          */
3284         if ((res >> 28) == ALC880_HP_EVENT)
3285                 alc880_medion_rim_automute(codec);
3286 }
3287
3288 static void alc880_medion_rim_setup(struct hda_codec *codec)
3289 {
3290         struct alc_spec *spec = codec->spec;
3291
3292         spec->autocfg.hp_pins[0] = 0x14;
3293         spec->autocfg.speaker_pins[0] = 0x1b;
3294 }
3295
3296 #ifdef CONFIG_SND_HDA_POWER_SAVE
3297 static struct hda_amp_list alc880_loopbacks[] = {
3298         { 0x0b, HDA_INPUT, 0 },
3299         { 0x0b, HDA_INPUT, 1 },
3300         { 0x0b, HDA_INPUT, 2 },
3301         { 0x0b, HDA_INPUT, 3 },
3302         { 0x0b, HDA_INPUT, 4 },
3303         { } /* end */
3304 };
3305
3306 static struct hda_amp_list alc880_lg_loopbacks[] = {
3307         { 0x0b, HDA_INPUT, 1 },
3308         { 0x0b, HDA_INPUT, 6 },
3309         { 0x0b, HDA_INPUT, 7 },
3310         { } /* end */
3311 };
3312 #endif
3313
3314 /*
3315  * Common callbacks
3316  */
3317
3318 static int alc_init(struct hda_codec *codec)
3319 {
3320         struct alc_spec *spec = codec->spec;
3321         unsigned int i;
3322
3323         alc_fix_pll(codec);
3324         alc_auto_init_amp(codec, spec->init_amp);
3325
3326         for (i = 0; i < spec->num_init_verbs; i++)
3327                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3328
3329         if (spec->init_hook)
3330                 spec->init_hook(codec);
3331
3332         return 0;
3333 }
3334
3335 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3336 {
3337         struct alc_spec *spec = codec->spec;
3338
3339         if (spec->unsol_event)
3340                 spec->unsol_event(codec, res);
3341 }
3342
3343 #ifdef CONFIG_SND_HDA_POWER_SAVE
3344 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3345 {
3346         struct alc_spec *spec = codec->spec;
3347         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3348 }
3349 #endif
3350
3351 /*
3352  * Analog playback callbacks
3353  */
3354 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3355                                     struct hda_codec *codec,
3356                                     struct snd_pcm_substream *substream)
3357 {
3358         struct alc_spec *spec = codec->spec;
3359         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3360                                              hinfo);
3361 }
3362
3363 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3364                                        struct hda_codec *codec,
3365                                        unsigned int stream_tag,
3366                                        unsigned int format,
3367                                        struct snd_pcm_substream *substream)
3368 {
3369         struct alc_spec *spec = codec->spec;
3370         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3371                                                 stream_tag, format, substream);
3372 }
3373
3374 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3375                                        struct hda_codec *codec,
3376                                        struct snd_pcm_substream *substream)
3377 {
3378         struct alc_spec *spec = codec->spec;
3379         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3380 }
3381
3382 /*
3383  * Digital out
3384  */
3385 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3386                                         struct hda_codec *codec,
3387                                         struct snd_pcm_substream *substream)
3388 {
3389         struct alc_spec *spec = codec->spec;
3390         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3391 }
3392
3393 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3394                                            struct hda_codec *codec,
3395                                            unsigned int stream_tag,
3396                                            unsigned int format,
3397                                            struct snd_pcm_substream *substream)
3398 {
3399         struct alc_spec *spec = codec->spec;
3400         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3401                                              stream_tag, format, substream);
3402 }
3403
3404 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3405                                            struct hda_codec *codec,
3406                                            struct snd_pcm_substream *substream)
3407 {
3408         struct alc_spec *spec = codec->spec;
3409         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3410 }
3411
3412 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3413                                          struct hda_codec *codec,
3414                                          struct snd_pcm_substream *substream)
3415 {
3416         struct alc_spec *spec = codec->spec;
3417         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3418 }
3419
3420 /*
3421  * Analog capture
3422  */
3423 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3424                                       struct hda_codec *codec,
3425                                       unsigned int stream_tag,
3426                                       unsigned int format,
3427                                       struct snd_pcm_substream *substream)
3428 {
3429         struct alc_spec *spec = codec->spec;
3430
3431         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3432                                    stream_tag, 0, format);
3433         return 0;
3434 }
3435
3436 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3437                                       struct hda_codec *codec,
3438                                       struct snd_pcm_substream *substream)
3439 {
3440         struct alc_spec *spec = codec->spec;
3441
3442         snd_hda_codec_cleanup_stream(codec,
3443                                      spec->adc_nids[substream->number + 1]);
3444         return 0;
3445 }
3446
3447
3448 /*
3449  */
3450 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3451         .substreams = 1,
3452         .channels_min = 2,
3453         .channels_max = 8,
3454         /* NID is set in alc_build_pcms */
3455         .ops = {
3456                 .open = alc880_playback_pcm_open,
3457                 .prepare = alc880_playback_pcm_prepare,
3458                 .cleanup = alc880_playback_pcm_cleanup
3459         },
3460 };
3461
3462 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3463         .substreams = 1,
3464         .channels_min = 2,
3465         .channels_max = 2,
3466         /* NID is set in alc_build_pcms */
3467 };
3468
3469 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3470         .substreams = 1,
3471         .channels_min = 2,
3472         .channels_max = 2,
3473         /* NID is set in alc_build_pcms */
3474 };
3475
3476 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3477         .substreams = 2, /* can be overridden */
3478         .channels_min = 2,
3479         .channels_max = 2,
3480         /* NID is set in alc_build_pcms */
3481         .ops = {
3482                 .prepare = alc880_alt_capture_pcm_prepare,
3483                 .cleanup = alc880_alt_capture_pcm_cleanup
3484         },
3485 };
3486
3487 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3488         .substreams = 1,
3489         .channels_min = 2,
3490         .channels_max = 2,
3491         /* NID is set in alc_build_pcms */
3492         .ops = {
3493                 .open = alc880_dig_playback_pcm_open,
3494                 .close = alc880_dig_playback_pcm_close,
3495                 .prepare = alc880_dig_playback_pcm_prepare,
3496                 .cleanup = alc880_dig_playback_pcm_cleanup
3497         },
3498 };
3499
3500 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3501         .substreams = 1,
3502         .channels_min = 2,
3503         .channels_max = 2,
3504         /* NID is set in alc_build_pcms */
3505 };
3506
3507 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3508 static struct hda_pcm_stream alc_pcm_null_stream = {
3509         .substreams = 0,
3510         .channels_min = 0,
3511         .channels_max = 0,
3512 };
3513
3514 static int alc_build_pcms(struct hda_codec *codec)
3515 {
3516         struct alc_spec *spec = codec->spec;
3517         struct hda_pcm *info = spec->pcm_rec;
3518         int i;
3519
3520         codec->num_pcms = 1;
3521         codec->pcm_info = info;
3522
3523         if (spec->no_analog)
3524                 goto skip_analog;
3525
3526         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3527                  "%s Analog", codec->chip_name);
3528         info->name = spec->stream_name_analog;
3529
3530         if (spec->stream_analog_playback) {
3531                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3532                         return -EINVAL;
3533                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3534                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3535         }
3536         if (spec->stream_analog_capture) {
3537                 if (snd_BUG_ON(!spec->adc_nids))
3538                         return -EINVAL;
3539                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3540                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3541         }
3542
3543         if (spec->channel_mode) {
3544                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3545                 for (i = 0; i < spec->num_channel_mode; i++) {
3546                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3547                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3548                         }
3549                 }
3550         }
3551
3552  skip_analog:
3553         /* SPDIF for stream index #1 */
3554         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3555                 snprintf(spec->stream_name_digital,
3556                          sizeof(spec->stream_name_digital),
3557                          "%s Digital", codec->chip_name);
3558                 codec->num_pcms = 2;
3559                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3560                 info = spec->pcm_rec + 1;
3561                 info->name = spec->stream_name_digital;
3562                 if (spec->dig_out_type)
3563                         info->pcm_type = spec->dig_out_type;
3564                 else
3565                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3566                 if (spec->multiout.dig_out_nid &&
3567                     spec->stream_digital_playback) {
3568                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3569                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3570                 }
3571                 if (spec->dig_in_nid &&
3572                     spec->stream_digital_capture) {
3573                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3574                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3575                 }
3576                 /* FIXME: do we need this for all Realtek codec models? */
3577                 codec->spdif_status_reset = 1;
3578         }
3579
3580         if (spec->no_analog)
3581                 return 0;
3582
3583         /* If the use of more than one ADC is requested for the current
3584          * model, configure a second analog capture-only PCM.
3585          */
3586         /* Additional Analaog capture for index #2 */
3587         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3588             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3589                 codec->num_pcms = 3;
3590                 info = spec->pcm_rec + 2;
3591                 info->name = spec->stream_name_analog;
3592                 if (spec->alt_dac_nid) {
3593                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3594                                 *spec->stream_analog_alt_playback;
3595                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3596                                 spec->alt_dac_nid;
3597                 } else {
3598                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3599                                 alc_pcm_null_stream;
3600                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3601                 }
3602                 if (spec->num_adc_nids > 1) {
3603                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3604                                 *spec->stream_analog_alt_capture;
3605                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3606                                 spec->adc_nids[1];
3607                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3608                                 spec->num_adc_nids - 1;
3609                 } else {
3610                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3611                                 alc_pcm_null_stream;
3612                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3613                 }
3614         }
3615
3616         return 0;
3617 }
3618
3619 static void alc_free_kctls(struct hda_codec *codec)
3620 {
3621         struct alc_spec *spec = codec->spec;
3622
3623         if (spec->kctls.list) {
3624                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3625                 int i;
3626                 for (i = 0; i < spec->kctls.used; i++)
3627                         kfree(kctl[i].name);
3628         }
3629         snd_array_free(&spec->kctls);
3630 }
3631
3632 static void alc_free(struct hda_codec *codec)
3633 {
3634         struct alc_spec *spec = codec->spec;
3635
3636         if (!spec)
3637                 return;
3638
3639         alc_free_kctls(codec);
3640         kfree(spec);
3641         snd_hda_detach_beep_device(codec);
3642 }
3643
3644 #ifdef CONFIG_SND_HDA_POWER_SAVE
3645 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3646 {
3647         struct alc_spec *spec = codec->spec;
3648         if (spec && spec->power_hook)
3649                 spec->power_hook(codec, 0);
3650         return 0;
3651 }
3652 #endif
3653
3654 #ifdef SND_HDA_NEEDS_RESUME
3655 static int alc_resume(struct hda_codec *codec)
3656 {
3657 #ifdef CONFIG_SND_HDA_POWER_SAVE
3658         struct alc_spec *spec = codec->spec;
3659 #endif
3660         codec->patch_ops.init(codec);
3661         snd_hda_codec_resume_amp(codec);
3662         snd_hda_codec_resume_cache(codec);
3663 #ifdef CONFIG_SND_HDA_POWER_SAVE
3664         if (spec && spec->power_hook)
3665                 spec->power_hook(codec, 1);
3666 #endif
3667         return 0;
3668 }
3669 #endif
3670
3671 /*
3672  */
3673 static struct hda_codec_ops alc_patch_ops = {
3674         .build_controls = alc_build_controls,
3675         .build_pcms = alc_build_pcms,
3676         .init = alc_init,
3677         .free = alc_free,
3678         .unsol_event = alc_unsol_event,
3679 #ifdef SND_HDA_NEEDS_RESUME
3680         .resume = alc_resume,
3681 #endif
3682 #ifdef CONFIG_SND_HDA_POWER_SAVE
3683         .suspend = alc_suspend,
3684         .check_power_status = alc_check_power_status,
3685 #endif
3686 };
3687
3688
3689 /*
3690  * Test configuration for debugging
3691  *
3692  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3693  * enum controls.
3694  */
3695 #ifdef CONFIG_SND_DEBUG
3696 static hda_nid_t alc880_test_dac_nids[4] = {
3697         0x02, 0x03, 0x04, 0x05
3698 };
3699
3700 static struct hda_input_mux alc880_test_capture_source = {
3701         .num_items = 7,
3702         .items = {
3703                 { "In-1", 0x0 },
3704                 { "In-2", 0x1 },
3705                 { "In-3", 0x2 },
3706                 { "In-4", 0x3 },
3707                 { "CD", 0x4 },
3708                 { "Front", 0x5 },
3709                 { "Surround", 0x6 },
3710         },
3711 };
3712
3713 static struct hda_channel_mode alc880_test_modes[4] = {
3714         { 2, NULL },
3715         { 4, NULL },
3716         { 6, NULL },
3717         { 8, NULL },
3718 };
3719
3720 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3721                                  struct snd_ctl_elem_info *uinfo)
3722 {
3723         static char *texts[] = {
3724                 "N/A", "Line Out", "HP Out",
3725                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3726         };
3727         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3728         uinfo->count = 1;
3729         uinfo->value.enumerated.items = 8;
3730         if (uinfo->value.enumerated.item >= 8)
3731                 uinfo->value.enumerated.item = 7;
3732         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3733         return 0;
3734 }
3735
3736 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3737                                 struct snd_ctl_elem_value *ucontrol)
3738 {
3739         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3740         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3741         unsigned int pin_ctl, item = 0;
3742
3743         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3744                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3745         if (pin_ctl & AC_PINCTL_OUT_EN) {
3746                 if (pin_ctl & AC_PINCTL_HP_EN)
3747                         item = 2;
3748                 else
3749                         item = 1;
3750         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3751                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3752                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3753                 case AC_PINCTL_VREF_50:  item = 4; break;
3754                 case AC_PINCTL_VREF_GRD: item = 5; break;
3755                 case AC_PINCTL_VREF_80:  item = 6; break;
3756                 case AC_PINCTL_VREF_100: item = 7; break;
3757                 }
3758         }
3759         ucontrol->value.enumerated.item[0] = item;
3760         return 0;
3761 }
3762
3763 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3764                                 struct snd_ctl_elem_value *ucontrol)
3765 {
3766         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3767         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3768         static unsigned int ctls[] = {
3769                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3770                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3771                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3772                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3773                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3774                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3775         };
3776         unsigned int old_ctl, new_ctl;
3777
3778         old_ctl = snd_hda_codec_read(codec, nid, 0,
3779                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3780         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3781         if (old_ctl != new_ctl) {
3782                 int val;
3783                 snd_hda_codec_write_cache(codec, nid, 0,
3784                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3785                                           new_ctl);
3786                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3787                         HDA_AMP_MUTE : 0;
3788                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3789                                          HDA_AMP_MUTE, val);
3790                 return 1;
3791         }
3792         return 0;
3793 }
3794
3795 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3796                                  struct snd_ctl_elem_info *uinfo)
3797 {
3798         static char *texts[] = {
3799                 "Front", "Surround", "CLFE", "Side"
3800         };
3801         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3802         uinfo->count = 1;
3803         uinfo->value.enumerated.items = 4;
3804         if (uinfo->value.enumerated.item >= 4)
3805                 uinfo->value.enumerated.item = 3;
3806         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3807         return 0;
3808 }
3809
3810 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3811                                 struct snd_ctl_elem_value *ucontrol)
3812 {
3813         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3814         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3815         unsigned int sel;
3816
3817         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3818         ucontrol->value.enumerated.item[0] = sel & 3;
3819         return 0;
3820 }
3821
3822 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3823                                 struct snd_ctl_elem_value *ucontrol)
3824 {
3825         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3826         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3827         unsigned int sel;
3828
3829         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3830         if (ucontrol->value.enumerated.item[0] != sel) {
3831                 sel = ucontrol->value.enumerated.item[0] & 3;
3832                 snd_hda_codec_write_cache(codec, nid, 0,
3833                                           AC_VERB_SET_CONNECT_SEL, sel);
3834                 return 1;
3835         }
3836         return 0;
3837 }
3838
3839 #define PIN_CTL_TEST(xname,nid) {                       \
3840                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3841                         .name = xname,                 \
3842                         .info = alc_test_pin_ctl_info, \
3843                         .get = alc_test_pin_ctl_get,   \
3844                         .put = alc_test_pin_ctl_put,   \
3845                         .private_value = nid           \
3846                         }
3847
3848 #define PIN_SRC_TEST(xname,nid) {                       \
3849                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3850                         .name = xname,                 \
3851                         .info = alc_test_pin_src_info, \
3852                         .get = alc_test_pin_src_get,   \
3853                         .put = alc_test_pin_src_put,   \
3854                         .private_value = nid           \
3855                         }
3856
3857 static struct snd_kcontrol_new alc880_test_mixer[] = {
3858         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3859         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3860         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3861         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3862         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3863         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3864         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3865         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3866         PIN_CTL_TEST("Front Pin Mode", 0x14),
3867         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3868         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3869         PIN_CTL_TEST("Side Pin Mode", 0x17),
3870         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3871         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3872         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3873         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3874         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3875         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3876         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3877         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3878         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3879         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3880         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3881         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3882         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3883         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3884         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3885         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3886         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3887         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3888         {
3889                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3890                 .name = "Channel Mode",
3891                 .info = alc_ch_mode_info,
3892                 .get = alc_ch_mode_get,
3893                 .put = alc_ch_mode_put,
3894         },
3895         { } /* end */
3896 };
3897
3898 static struct hda_verb alc880_test_init_verbs[] = {
3899         /* Unmute inputs of 0x0c - 0x0f */
3900         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3901         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3902         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3903         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3904         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3905         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3906         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3907         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3908         /* Vol output for 0x0c-0x0f */
3909         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3910         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3911         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3912         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3913         /* Set output pins 0x14-0x17 */
3914         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3915         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3916         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3917         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3918         /* Unmute output pins 0x14-0x17 */
3919         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3920         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3921         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3922         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3923         /* Set input pins 0x18-0x1c */
3924         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3925         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3926         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3927         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3928         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3929         /* Mute input pins 0x18-0x1b */
3930         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3931         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3932         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3933         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3934         /* ADC set up */
3935         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3936         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3937         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3938         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3939         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3940         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3941         /* Analog input/passthru */
3942         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3943         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3944         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3945         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3946         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3947         { }
3948 };
3949 #endif
3950
3951 /*
3952  */
3953
3954 static const char *alc880_models[ALC880_MODEL_LAST] = {
3955         [ALC880_3ST]            = "3stack",
3956         [ALC880_TCL_S700]       = "tcl",
3957         [ALC880_3ST_DIG]        = "3stack-digout",
3958         [ALC880_CLEVO]          = "clevo",
3959         [ALC880_5ST]            = "5stack",
3960         [ALC880_5ST_DIG]        = "5stack-digout",
3961         [ALC880_W810]           = "w810",
3962         [ALC880_Z71V]           = "z71v",
3963         [ALC880_6ST]            = "6stack",
3964         [ALC880_6ST_DIG]        = "6stack-digout",
3965         [ALC880_ASUS]           = "asus",
3966         [ALC880_ASUS_W1V]       = "asus-w1v",
3967         [ALC880_ASUS_DIG]       = "asus-dig",
3968         [ALC880_ASUS_DIG2]      = "asus-dig2",
3969         [ALC880_UNIWILL_DIG]    = "uniwill",
3970         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3971         [ALC880_FUJITSU]        = "fujitsu",
3972         [ALC880_F1734]          = "F1734",
3973         [ALC880_LG]             = "lg",
3974         [ALC880_LG_LW]          = "lg-lw",
3975         [ALC880_MEDION_RIM]     = "medion",
3976 #ifdef CONFIG_SND_DEBUG
3977         [ALC880_TEST]           = "test",
3978 #endif
3979         [ALC880_AUTO]           = "auto",
3980 };
3981
3982 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3983         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3984         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3985         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3986         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3987         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3988         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3989         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3990         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3991         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3992         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3993         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3994         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3995         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3996         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3997         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3998         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3999         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4000         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4001         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4002         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4003         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4004         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4005         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4006         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4007         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4008         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4009         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4010         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4011         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4012         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4013         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4014         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4015         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4016         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4017         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4018         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4019         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4020         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4021         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4022         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4023         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4024         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4025         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4026         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4027         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4028         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4029         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4030         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4031         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4032         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4033         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4034         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4035         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4036         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4037         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4038         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4039         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4040         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4041         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4042         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4043         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4044         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4045         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4046         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4047         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4048         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4049         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4050         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4051         /* default Intel */
4052         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4053         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4054         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4055         {}
4056 };
4057
4058 /*
4059  * ALC880 codec presets
4060  */
4061 static struct alc_config_preset alc880_presets[] = {
4062         [ALC880_3ST] = {
4063                 .mixers = { alc880_three_stack_mixer },
4064                 .init_verbs = { alc880_volume_init_verbs,
4065                                 alc880_pin_3stack_init_verbs },
4066                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4067                 .dac_nids = alc880_dac_nids,
4068                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4069                 .channel_mode = alc880_threestack_modes,
4070                 .need_dac_fix = 1,
4071                 .input_mux = &alc880_capture_source,
4072         },
4073         [ALC880_3ST_DIG] = {
4074                 .mixers = { alc880_three_stack_mixer },
4075                 .init_verbs = { alc880_volume_init_verbs,
4076                                 alc880_pin_3stack_init_verbs },
4077                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4078                 .dac_nids = alc880_dac_nids,
4079                 .dig_out_nid = ALC880_DIGOUT_NID,
4080                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4081                 .channel_mode = alc880_threestack_modes,
4082                 .need_dac_fix = 1,
4083                 .input_mux = &alc880_capture_source,
4084         },
4085         [ALC880_TCL_S700] = {
4086                 .mixers = { alc880_tcl_s700_mixer },
4087                 .init_verbs = { alc880_volume_init_verbs,
4088                                 alc880_pin_tcl_S700_init_verbs,
4089                                 alc880_gpio2_init_verbs },
4090                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4091                 .dac_nids = alc880_dac_nids,
4092                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4093                 .num_adc_nids = 1, /* single ADC */
4094                 .hp_nid = 0x03,
4095                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4096                 .channel_mode = alc880_2_jack_modes,
4097                 .input_mux = &alc880_capture_source,
4098         },
4099         [ALC880_5ST] = {
4100                 .mixers = { alc880_three_stack_mixer,
4101                             alc880_five_stack_mixer},
4102                 .init_verbs = { alc880_volume_init_verbs,
4103                                 alc880_pin_5stack_init_verbs },
4104                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4105                 .dac_nids = alc880_dac_nids,
4106                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4107                 .channel_mode = alc880_fivestack_modes,
4108                 .input_mux = &alc880_capture_source,
4109         },
4110         [ALC880_5ST_DIG] = {
4111                 .mixers = { alc880_three_stack_mixer,
4112                             alc880_five_stack_mixer },
4113                 .init_verbs = { alc880_volume_init_verbs,
4114                                 alc880_pin_5stack_init_verbs },
4115                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4116                 .dac_nids = alc880_dac_nids,
4117                 .dig_out_nid = ALC880_DIGOUT_NID,
4118                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4119                 .channel_mode = alc880_fivestack_modes,
4120                 .input_mux = &alc880_capture_source,
4121         },
4122         [ALC880_6ST] = {
4123                 .mixers = { alc880_six_stack_mixer },
4124                 .init_verbs = { alc880_volume_init_verbs,
4125                                 alc880_pin_6stack_init_verbs },
4126                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4127                 .dac_nids = alc880_6st_dac_nids,
4128                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4129                 .channel_mode = alc880_sixstack_modes,
4130                 .input_mux = &alc880_6stack_capture_source,
4131         },
4132         [ALC880_6ST_DIG] = {
4133                 .mixers = { alc880_six_stack_mixer },
4134                 .init_verbs = { alc880_volume_init_verbs,
4135                                 alc880_pin_6stack_init_verbs },
4136                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4137                 .dac_nids = alc880_6st_dac_nids,
4138                 .dig_out_nid = ALC880_DIGOUT_NID,
4139                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4140                 .channel_mode = alc880_sixstack_modes,
4141                 .input_mux = &alc880_6stack_capture_source,
4142         },
4143         [ALC880_W810] = {
4144                 .mixers = { alc880_w810_base_mixer },
4145                 .init_verbs = { alc880_volume_init_verbs,
4146                                 alc880_pin_w810_init_verbs,
4147                                 alc880_gpio2_init_verbs },
4148                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4149                 .dac_nids = alc880_w810_dac_nids,
4150                 .dig_out_nid = ALC880_DIGOUT_NID,
4151                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4152                 .channel_mode = alc880_w810_modes,
4153                 .input_mux = &alc880_capture_source,
4154         },
4155         [ALC880_Z71V] = {
4156                 .mixers = { alc880_z71v_mixer },
4157                 .init_verbs = { alc880_volume_init_verbs,
4158                                 alc880_pin_z71v_init_verbs },
4159                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4160                 .dac_nids = alc880_z71v_dac_nids,
4161                 .dig_out_nid = ALC880_DIGOUT_NID,
4162                 .hp_nid = 0x03,
4163                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4164                 .channel_mode = alc880_2_jack_modes,
4165                 .input_mux = &alc880_capture_source,
4166         },
4167         [ALC880_F1734] = {
4168                 .mixers = { alc880_f1734_mixer },
4169                 .init_verbs = { alc880_volume_init_verbs,
4170                                 alc880_pin_f1734_init_verbs },
4171                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4172                 .dac_nids = alc880_f1734_dac_nids,
4173                 .hp_nid = 0x02,
4174                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4175                 .channel_mode = alc880_2_jack_modes,
4176                 .input_mux = &alc880_f1734_capture_source,
4177                 .unsol_event = alc880_uniwill_p53_unsol_event,
4178                 .setup = alc880_uniwill_p53_setup,
4179                 .init_hook = alc_automute_amp,
4180         },
4181         [ALC880_ASUS] = {
4182                 .mixers = { alc880_asus_mixer },
4183                 .init_verbs = { alc880_volume_init_verbs,
4184                                 alc880_pin_asus_init_verbs,
4185                                 alc880_gpio1_init_verbs },
4186                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4187                 .dac_nids = alc880_asus_dac_nids,
4188                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4189                 .channel_mode = alc880_asus_modes,
4190                 .need_dac_fix = 1,
4191                 .input_mux = &alc880_capture_source,
4192         },
4193         [ALC880_ASUS_DIG] = {
4194                 .mixers = { alc880_asus_mixer },
4195                 .init_verbs = { alc880_volume_init_verbs,
4196                                 alc880_pin_asus_init_verbs,
4197                                 alc880_gpio1_init_verbs },
4198                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4199                 .dac_nids = alc880_asus_dac_nids,
4200                 .dig_out_nid = ALC880_DIGOUT_NID,
4201                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4202                 .channel_mode = alc880_asus_modes,
4203                 .need_dac_fix = 1,
4204                 .input_mux = &alc880_capture_source,
4205         },
4206         [ALC880_ASUS_DIG2] = {
4207                 .mixers = { alc880_asus_mixer },
4208                 .init_verbs = { alc880_volume_init_verbs,
4209                                 alc880_pin_asus_init_verbs,
4210                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4211                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4212                 .dac_nids = alc880_asus_dac_nids,
4213                 .dig_out_nid = ALC880_DIGOUT_NID,
4214                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4215                 .channel_mode = alc880_asus_modes,
4216                 .need_dac_fix = 1,
4217                 .input_mux = &alc880_capture_source,
4218         },
4219         [ALC880_ASUS_W1V] = {
4220                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4221                 .init_verbs = { alc880_volume_init_verbs,
4222                                 alc880_pin_asus_init_verbs,
4223                                 alc880_gpio1_init_verbs },
4224                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4225                 .dac_nids = alc880_asus_dac_nids,
4226                 .dig_out_nid = ALC880_DIGOUT_NID,
4227                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4228                 .channel_mode = alc880_asus_modes,
4229                 .need_dac_fix = 1,
4230                 .input_mux = &alc880_capture_source,
4231         },
4232         [ALC880_UNIWILL_DIG] = {
4233                 .mixers = { alc880_asus_mixer },
4234                 .init_verbs = { alc880_volume_init_verbs,
4235                                 alc880_pin_asus_init_verbs },
4236                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4237                 .dac_nids = alc880_asus_dac_nids,
4238                 .dig_out_nid = ALC880_DIGOUT_NID,
4239                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4240                 .channel_mode = alc880_asus_modes,
4241                 .need_dac_fix = 1,
4242                 .input_mux = &alc880_capture_source,
4243         },
4244         [ALC880_UNIWILL] = {
4245                 .mixers = { alc880_uniwill_mixer },
4246                 .init_verbs = { alc880_volume_init_verbs,
4247                                 alc880_uniwill_init_verbs },
4248                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4249                 .dac_nids = alc880_asus_dac_nids,
4250                 .dig_out_nid = ALC880_DIGOUT_NID,
4251                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4252                 .channel_mode = alc880_threestack_modes,
4253                 .need_dac_fix = 1,
4254                 .input_mux = &alc880_capture_source,
4255                 .unsol_event = alc880_uniwill_unsol_event,
4256                 .setup = alc880_uniwill_setup,
4257                 .init_hook = alc880_uniwill_init_hook,
4258         },
4259         [ALC880_UNIWILL_P53] = {
4260                 .mixers = { alc880_uniwill_p53_mixer },
4261                 .init_verbs = { alc880_volume_init_verbs,
4262                                 alc880_uniwill_p53_init_verbs },
4263                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4264                 .dac_nids = alc880_asus_dac_nids,
4265                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4266                 .channel_mode = alc880_threestack_modes,
4267                 .input_mux = &alc880_capture_source,
4268                 .unsol_event = alc880_uniwill_p53_unsol_event,
4269                 .setup = alc880_uniwill_p53_setup,
4270                 .init_hook = alc_automute_amp,
4271         },
4272         [ALC880_FUJITSU] = {
4273                 .mixers = { alc880_fujitsu_mixer },
4274                 .init_verbs = { alc880_volume_init_verbs,
4275                                 alc880_uniwill_p53_init_verbs,
4276                                 alc880_beep_init_verbs },
4277                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4278                 .dac_nids = alc880_dac_nids,
4279                 .dig_out_nid = ALC880_DIGOUT_NID,
4280                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4281                 .channel_mode = alc880_2_jack_modes,
4282                 .input_mux = &alc880_capture_source,
4283                 .unsol_event = alc880_uniwill_p53_unsol_event,
4284                 .setup = alc880_uniwill_p53_setup,
4285                 .init_hook = alc_automute_amp,
4286         },
4287         [ALC880_CLEVO] = {
4288                 .mixers = { alc880_three_stack_mixer },
4289                 .init_verbs = { alc880_volume_init_verbs,
4290                                 alc880_pin_clevo_init_verbs },
4291                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4292                 .dac_nids = alc880_dac_nids,
4293                 .hp_nid = 0x03,
4294                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4295                 .channel_mode = alc880_threestack_modes,
4296                 .need_dac_fix = 1,
4297                 .input_mux = &alc880_capture_source,
4298         },
4299         [ALC880_LG] = {
4300                 .mixers = { alc880_lg_mixer },
4301                 .init_verbs = { alc880_volume_init_verbs,
4302                                 alc880_lg_init_verbs },
4303                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4304                 .dac_nids = alc880_lg_dac_nids,
4305                 .dig_out_nid = ALC880_DIGOUT_NID,
4306                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4307                 .channel_mode = alc880_lg_ch_modes,
4308                 .need_dac_fix = 1,
4309                 .input_mux = &alc880_lg_capture_source,
4310                 .unsol_event = alc_automute_amp_unsol_event,
4311                 .setup = alc880_lg_setup,
4312                 .init_hook = alc_automute_amp,
4313 #ifdef CONFIG_SND_HDA_POWER_SAVE
4314                 .loopbacks = alc880_lg_loopbacks,
4315 #endif
4316         },
4317         [ALC880_LG_LW] = {
4318                 .mixers = { alc880_lg_lw_mixer },
4319                 .init_verbs = { alc880_volume_init_verbs,
4320                                 alc880_lg_lw_init_verbs },
4321                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4322                 .dac_nids = alc880_dac_nids,
4323                 .dig_out_nid = ALC880_DIGOUT_NID,
4324                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4325                 .channel_mode = alc880_lg_lw_modes,
4326                 .input_mux = &alc880_lg_lw_capture_source,
4327                 .unsol_event = alc_automute_amp_unsol_event,
4328                 .setup = alc880_lg_lw_setup,
4329                 .init_hook = alc_automute_amp,
4330         },
4331         [ALC880_MEDION_RIM] = {
4332                 .mixers = { alc880_medion_rim_mixer },
4333                 .init_verbs = { alc880_volume_init_verbs,
4334                                 alc880_medion_rim_init_verbs,
4335                                 alc_gpio2_init_verbs },
4336                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4337                 .dac_nids = alc880_dac_nids,
4338                 .dig_out_nid = ALC880_DIGOUT_NID,
4339                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4340                 .channel_mode = alc880_2_jack_modes,
4341                 .input_mux = &alc880_medion_rim_capture_source,
4342                 .unsol_event = alc880_medion_rim_unsol_event,
4343                 .setup = alc880_medion_rim_setup,
4344                 .init_hook = alc880_medion_rim_automute,
4345         },
4346 #ifdef CONFIG_SND_DEBUG
4347         [ALC880_TEST] = {
4348                 .mixers = { alc880_test_mixer },
4349                 .init_verbs = { alc880_test_init_verbs },
4350                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4351                 .dac_nids = alc880_test_dac_nids,
4352                 .dig_out_nid = ALC880_DIGOUT_NID,
4353                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4354                 .channel_mode = alc880_test_modes,
4355                 .input_mux = &alc880_test_capture_source,
4356         },
4357 #endif
4358 };
4359
4360 /*
4361  * Automatic parse of I/O pins from the BIOS configuration
4362  */
4363
4364 enum {
4365         ALC_CTL_WIDGET_VOL,
4366         ALC_CTL_WIDGET_MUTE,
4367         ALC_CTL_BIND_MUTE,
4368 };
4369 static struct snd_kcontrol_new alc880_control_templates[] = {
4370         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4371         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4372         HDA_BIND_MUTE(NULL, 0, 0, 0),
4373 };
4374
4375 /* add dynamic controls */
4376 static int add_control(struct alc_spec *spec, int type, const char *name,
4377                        unsigned long val)
4378 {
4379         struct snd_kcontrol_new *knew;
4380
4381         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4382         knew = snd_array_new(&spec->kctls);
4383         if (!knew)
4384                 return -ENOMEM;
4385         *knew = alc880_control_templates[type];
4386         knew->name = kstrdup(name, GFP_KERNEL);
4387         if (!knew->name)
4388                 return -ENOMEM;
4389         if (get_amp_nid_(val))
4390                 knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val);
4391         knew->private_value = val;
4392         return 0;
4393 }
4394
4395 static int add_control_with_pfx(struct alc_spec *spec, int type,
4396                                 const char *pfx, const char *dir,
4397                                 const char *sfx, unsigned long val)
4398 {
4399         char name[32];
4400         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4401         return add_control(spec, type, name, val);
4402 }
4403
4404 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4405         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4406 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4407         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4408
4409 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4410 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4411 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4412 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4413 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4414 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4415 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4416 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4417 #define ALC880_PIN_CD_NID               0x1c
4418
4419 /* fill in the dac_nids table from the parsed pin configuration */
4420 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4421                                      const struct auto_pin_cfg *cfg)
4422 {
4423         hda_nid_t nid;
4424         int assigned[4];
4425         int i, j;
4426
4427         memset(assigned, 0, sizeof(assigned));
4428         spec->multiout.dac_nids = spec->private_dac_nids;
4429
4430         /* check the pins hardwired to audio widget */
4431         for (i = 0; i < cfg->line_outs; i++) {
4432                 nid = cfg->line_out_pins[i];
4433                 if (alc880_is_fixed_pin(nid)) {
4434                         int idx = alc880_fixed_pin_idx(nid);
4435                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4436                         assigned[idx] = 1;
4437                 }
4438         }
4439         /* left pins can be connect to any audio widget */
4440         for (i = 0; i < cfg->line_outs; i++) {
4441                 nid = cfg->line_out_pins[i];
4442                 if (alc880_is_fixed_pin(nid))
4443                         continue;
4444                 /* search for an empty channel */
4445                 for (j = 0; j < cfg->line_outs; j++) {
4446                         if (!assigned[j]) {
4447                                 spec->multiout.dac_nids[i] =
4448                                         alc880_idx_to_dac(j);
4449                                 assigned[j] = 1;
4450                                 break;
4451                         }
4452                 }
4453         }
4454         spec->multiout.num_dacs = cfg->line_outs;
4455         return 0;
4456 }
4457
4458 /* add playback controls from the parsed DAC table */
4459 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4460                                              const struct auto_pin_cfg *cfg)
4461 {
4462         static const char *chname[4] = {
4463                 "Front", "Surround", NULL /*CLFE*/, "Side"
4464         };
4465         hda_nid_t nid;
4466         int i, err;
4467
4468         for (i = 0; i < cfg->line_outs; i++) {
4469                 if (!spec->multiout.dac_nids[i])
4470                         continue;
4471                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4472                 if (i == 2) {
4473                         /* Center/LFE */
4474                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4475                                               "Center",
4476                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4477                                                               HDA_OUTPUT));
4478                         if (err < 0)
4479                                 return err;
4480                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4481                                               "LFE",
4482                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4483                                                               HDA_OUTPUT));
4484                         if (err < 0)
4485                                 return err;
4486                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4487                                              "Center",
4488                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4489                                                               HDA_INPUT));
4490                         if (err < 0)
4491                                 return err;
4492                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4493                                              "LFE",
4494                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4495                                                               HDA_INPUT));
4496                         if (err < 0)
4497                                 return err;
4498                 } else {
4499                         const char *pfx;
4500                         if (cfg->line_outs == 1 &&
4501                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4502                                 pfx = "Speaker";
4503                         else
4504                                 pfx = chname[i];
4505                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4506                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4507                                                               HDA_OUTPUT));
4508                         if (err < 0)
4509                                 return err;
4510                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4511                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4512                                                               HDA_INPUT));
4513                         if (err < 0)
4514                                 return err;
4515                 }
4516         }
4517         return 0;
4518 }
4519
4520 /* add playback controls for speaker and HP outputs */
4521 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4522                                         const char *pfx)
4523 {
4524         hda_nid_t nid;
4525         int err;
4526
4527         if (!pin)
4528                 return 0;
4529
4530         if (alc880_is_fixed_pin(pin)) {
4531                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4532                 /* specify the DAC as the extra output */
4533                 if (!spec->multiout.hp_nid)
4534                         spec->multiout.hp_nid = nid;
4535                 else
4536                         spec->multiout.extra_out_nid[0] = nid;
4537                 /* control HP volume/switch on the output mixer amp */
4538                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4539                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4540                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4541                 if (err < 0)
4542                         return err;
4543                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4544                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4545                 if (err < 0)
4546                         return err;
4547         } else if (alc880_is_multi_pin(pin)) {
4548                 /* set manual connection */
4549                 /* we have only a switch on HP-out PIN */
4550                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4551                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4552                 if (err < 0)
4553                         return err;
4554         }
4555         return 0;
4556 }
4557
4558 /* create input playback/capture controls for the given pin */
4559 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4560                             const char *ctlname,
4561                             int idx, hda_nid_t mix_nid)
4562 {
4563         int err;
4564
4565         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4566                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4567         if (err < 0)
4568                 return err;
4569         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4570                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4571         if (err < 0)
4572                 return err;
4573         return 0;
4574 }
4575
4576 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4577 {
4578         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4579         return (pincap & AC_PINCAP_IN) != 0;
4580 }
4581
4582 /* create playback/capture controls for input pins */
4583 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4584                                       const struct auto_pin_cfg *cfg,
4585                                       hda_nid_t mixer,
4586                                       hda_nid_t cap1, hda_nid_t cap2)
4587 {
4588         struct alc_spec *spec = codec->spec;
4589         struct hda_input_mux *imux = &spec->private_imux[0];
4590         int i, err, idx;
4591
4592         for (i = 0; i < AUTO_PIN_LAST; i++) {
4593                 hda_nid_t pin;
4594
4595                 pin = cfg->input_pins[i];
4596                 if (!alc_is_input_pin(codec, pin))
4597                         continue;
4598
4599                 if (mixer) {
4600                         idx = get_connection_index(codec, mixer, pin);
4601                         if (idx >= 0) {
4602                                 err = new_analog_input(spec, pin,
4603                                                        auto_pin_cfg_labels[i],
4604                                                        idx, mixer);
4605                                 if (err < 0)
4606                                         return err;
4607                         }
4608                 }
4609
4610                 if (!cap1)
4611                         continue;
4612                 idx = get_connection_index(codec, cap1, pin);
4613                 if (idx < 0 && cap2)
4614                         idx = get_connection_index(codec, cap2, pin);
4615                 if (idx >= 0) {
4616                         imux->items[imux->num_items].label =
4617                                 auto_pin_cfg_labels[i];
4618                         imux->items[imux->num_items].index = idx;
4619                         imux->num_items++;
4620                 }
4621         }
4622         return 0;
4623 }
4624
4625 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4626                                                 const struct auto_pin_cfg *cfg)
4627 {
4628         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4629 }
4630
4631 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4632                                unsigned int pin_type)
4633 {
4634         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4635                             pin_type);
4636         /* unmute pin */
4637         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4638                             AMP_OUT_UNMUTE);
4639 }
4640
4641 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4642                                               hda_nid_t nid, int pin_type,
4643                                               int dac_idx)
4644 {
4645         alc_set_pin_output(codec, nid, pin_type);
4646         /* need the manual connection? */
4647         if (alc880_is_multi_pin(nid)) {
4648                 struct alc_spec *spec = codec->spec;
4649                 int idx = alc880_multi_pin_idx(nid);
4650                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4651                                     AC_VERB_SET_CONNECT_SEL,
4652                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4653         }
4654 }
4655
4656 static int get_pin_type(int line_out_type)
4657 {
4658         if (line_out_type == AUTO_PIN_HP_OUT)
4659                 return PIN_HP;
4660         else
4661                 return PIN_OUT;
4662 }
4663
4664 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4665 {
4666         struct alc_spec *spec = codec->spec;
4667         int i;
4668
4669         for (i = 0; i < spec->autocfg.line_outs; i++) {
4670                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4671                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4672                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4673         }
4674 }
4675
4676 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4677 {
4678         struct alc_spec *spec = codec->spec;
4679         hda_nid_t pin;
4680
4681         pin = spec->autocfg.speaker_pins[0];
4682         if (pin) /* connect to front */
4683                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4684         pin = spec->autocfg.hp_pins[0];
4685         if (pin) /* connect to front */
4686                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4687 }
4688
4689 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4690 {
4691         struct alc_spec *spec = codec->spec;
4692         int i;
4693
4694         for (i = 0; i < AUTO_PIN_LAST; i++) {
4695                 hda_nid_t nid = spec->autocfg.input_pins[i];
4696                 if (alc_is_input_pin(codec, nid)) {
4697                         alc_set_input_pin(codec, nid, i);
4698                         if (nid != ALC880_PIN_CD_NID &&
4699                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4700                                 snd_hda_codec_write(codec, nid, 0,
4701                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4702                                                     AMP_OUT_MUTE);
4703                 }
4704         }
4705 }
4706
4707 /* parse the BIOS configuration and set up the alc_spec */
4708 /* return 1 if successful, 0 if the proper config is not found,
4709  * or a negative error code
4710  */
4711 static int alc880_parse_auto_config(struct hda_codec *codec)
4712 {
4713         struct alc_spec *spec = codec->spec;
4714         int i, err;
4715         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4716
4717         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4718                                            alc880_ignore);
4719         if (err < 0)
4720                 return err;
4721         if (!spec->autocfg.line_outs)
4722                 return 0; /* can't find valid BIOS pin config */
4723
4724         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4725         if (err < 0)
4726                 return err;
4727         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4728         if (err < 0)
4729                 return err;
4730         err = alc880_auto_create_extra_out(spec,
4731                                            spec->autocfg.speaker_pins[0],
4732                                            "Speaker");
4733         if (err < 0)
4734                 return err;
4735         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4736                                            "Headphone");
4737         if (err < 0)
4738                 return err;
4739         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4740         if (err < 0)
4741                 return err;
4742
4743         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4744
4745         /* check multiple SPDIF-out (for recent codecs) */
4746         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4747                 hda_nid_t dig_nid;
4748                 err = snd_hda_get_connections(codec,
4749                                               spec->autocfg.dig_out_pins[i],
4750                                               &dig_nid, 1);
4751                 if (err < 0)
4752                         continue;
4753                 if (!i)
4754                         spec->multiout.dig_out_nid = dig_nid;
4755                 else {
4756                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4757                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4758                                 break;
4759                         spec->slave_dig_outs[i - 1] = dig_nid;
4760                 }
4761         }
4762         if (spec->autocfg.dig_in_pin)
4763                 spec->dig_in_nid = ALC880_DIGIN_NID;
4764
4765         if (spec->kctls.list)
4766                 add_mixer(spec, spec->kctls.list);
4767
4768         add_verb(spec, alc880_volume_init_verbs);
4769
4770         spec->num_mux_defs = 1;
4771         spec->input_mux = &spec->private_imux[0];
4772
4773         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4774
4775         return 1;
4776 }
4777
4778 /* additional initialization for auto-configuration model */
4779 static void alc880_auto_init(struct hda_codec *codec)
4780 {
4781         struct alc_spec *spec = codec->spec;
4782         alc880_auto_init_multi_out(codec);
4783         alc880_auto_init_extra_out(codec);
4784         alc880_auto_init_analog_input(codec);
4785         if (spec->unsol_event)
4786                 alc_inithook(codec);
4787 }
4788
4789 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4790  * one of two digital mic pins, e.g. on ALC272
4791  */
4792 static void fixup_automic_adc(struct hda_codec *codec)
4793 {
4794         struct alc_spec *spec = codec->spec;
4795         int i;
4796
4797         for (i = 0; i < spec->num_adc_nids; i++) {
4798                 hda_nid_t cap = spec->capsrc_nids ?
4799                         spec->capsrc_nids[i] : spec->adc_nids[i];
4800                 int iidx, eidx;
4801
4802                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4803                 if (iidx < 0)
4804                         continue;
4805                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4806                 if (eidx < 0)
4807                         continue;
4808                 spec->int_mic.mux_idx = iidx;
4809                 spec->ext_mic.mux_idx = eidx;
4810                 if (spec->capsrc_nids)
4811                         spec->capsrc_nids += i;
4812                 spec->adc_nids += i;
4813                 spec->num_adc_nids = 1;
4814                 return;
4815         }
4816         snd_printd(KERN_INFO "hda_codec: %s: "
4817                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4818                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4819         spec->auto_mic = 0; /* disable auto-mic to be sure */
4820 }
4821
4822 /* choose the ADC/MUX containing the input pin and initialize the setup */
4823 static void fixup_single_adc(struct hda_codec *codec)
4824 {
4825         struct alc_spec *spec = codec->spec;
4826         hda_nid_t pin;
4827         int i;
4828
4829         /* search for the input pin; there must be only one */
4830         for (i = 0; i < AUTO_PIN_LAST; i++) {
4831                 if (spec->autocfg.input_pins[i]) {
4832                         pin = spec->autocfg.input_pins[i];
4833                         break;
4834                 }
4835         }
4836         if (!pin)
4837                 return;
4838
4839         /* set the default connection to that pin */
4840         for (i = 0; i < spec->num_adc_nids; i++) {
4841                 hda_nid_t cap = spec->capsrc_nids ?
4842                         spec->capsrc_nids[i] : spec->adc_nids[i];
4843                 int idx;
4844
4845                 idx = get_connection_index(codec, cap, pin);
4846                 if (idx < 0)
4847                         continue;
4848                 /* use only this ADC */
4849                 if (spec->capsrc_nids)
4850                         spec->capsrc_nids += i;
4851                 spec->adc_nids += i;
4852                 spec->num_adc_nids = 1;
4853                 /* select or unmute this route */
4854                 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
4855                         snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
4856                                                  HDA_AMP_MUTE, 0);
4857                 } else {
4858                         snd_hda_codec_write_cache(codec, cap, 0,
4859                                           AC_VERB_SET_CONNECT_SEL, idx);
4860                 }
4861                 return;
4862         }
4863 }
4864
4865 static void set_capture_mixer(struct hda_codec *codec)
4866 {
4867         struct alc_spec *spec = codec->spec;
4868         static struct snd_kcontrol_new *caps[2][3] = {
4869                 { alc_capture_mixer_nosrc1,
4870                   alc_capture_mixer_nosrc2,
4871                   alc_capture_mixer_nosrc3 },
4872                 { alc_capture_mixer1,
4873                   alc_capture_mixer2,
4874                   alc_capture_mixer3 },
4875         };
4876         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4877                 int mux = 0;
4878                 if (spec->auto_mic)
4879                         fixup_automic_adc(codec);
4880                 else if (spec->input_mux) {
4881                         if (spec->input_mux->num_items > 1)
4882                                 mux = 1;
4883                         else if (spec->input_mux->num_items == 1)
4884                                 fixup_single_adc(codec);
4885                 }
4886                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4887         }
4888 }
4889
4890 #ifdef CONFIG_SND_HDA_INPUT_BEEP
4891 #define set_beep_amp(spec, nid, idx, dir) \
4892         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4893 #else
4894 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
4895 #endif
4896
4897 /*
4898  * OK, here we have finally the patch for ALC880
4899  */
4900
4901 static int patch_alc880(struct hda_codec *codec)
4902 {
4903         struct alc_spec *spec;
4904         int board_config;
4905         int err;
4906
4907         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4908         if (spec == NULL)
4909                 return -ENOMEM;
4910
4911         codec->spec = spec;
4912
4913         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4914                                                   alc880_models,
4915                                                   alc880_cfg_tbl);
4916         if (board_config < 0) {
4917                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4918                        codec->chip_name);
4919                 board_config = ALC880_AUTO;
4920         }
4921
4922         if (board_config == ALC880_AUTO) {
4923                 /* automatic parse from the BIOS config */
4924                 err = alc880_parse_auto_config(codec);
4925                 if (err < 0) {
4926                         alc_free(codec);
4927                         return err;
4928                 } else if (!err) {
4929                         printk(KERN_INFO
4930                                "hda_codec: Cannot set up configuration "
4931                                "from BIOS.  Using 3-stack mode...\n");
4932                         board_config = ALC880_3ST;
4933                 }
4934         }
4935
4936         err = snd_hda_attach_beep_device(codec, 0x1);
4937         if (err < 0) {
4938                 alc_free(codec);
4939                 return err;
4940         }
4941
4942         if (board_config != ALC880_AUTO)
4943                 setup_preset(codec, &alc880_presets[board_config]);
4944
4945         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4946         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4947         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4948
4949         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4950         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4951
4952         if (!spec->adc_nids && spec->input_mux) {
4953                 /* check whether NID 0x07 is valid */
4954                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4955                 /* get type */
4956                 wcap = get_wcaps_type(wcap);
4957                 if (wcap != AC_WID_AUD_IN) {
4958                         spec->adc_nids = alc880_adc_nids_alt;
4959                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4960                 } else {
4961                         spec->adc_nids = alc880_adc_nids;
4962                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4963                 }
4964         }
4965         set_capture_mixer(codec);
4966         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4967
4968         spec->vmaster_nid = 0x0c;
4969
4970         codec->patch_ops = alc_patch_ops;
4971         if (board_config == ALC880_AUTO)
4972                 spec->init_hook = alc880_auto_init;
4973 #ifdef CONFIG_SND_HDA_POWER_SAVE
4974         if (!spec->loopback.amplist)
4975                 spec->loopback.amplist = alc880_loopbacks;
4976 #endif
4977         codec->proc_widget_hook = print_realtek_coef;
4978
4979         return 0;
4980 }
4981
4982
4983 /*
4984  * ALC260 support
4985  */
4986
4987 static hda_nid_t alc260_dac_nids[1] = {
4988         /* front */
4989         0x02,
4990 };
4991
4992 static hda_nid_t alc260_adc_nids[1] = {
4993         /* ADC0 */
4994         0x04,
4995 };
4996
4997 static hda_nid_t alc260_adc_nids_alt[1] = {
4998         /* ADC1 */
4999         0x05,
5000 };
5001
5002 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5003  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5004  */
5005 static hda_nid_t alc260_dual_adc_nids[2] = {
5006         /* ADC0, ADC1 */
5007         0x04, 0x05
5008 };
5009
5010 #define ALC260_DIGOUT_NID       0x03
5011 #define ALC260_DIGIN_NID        0x06
5012
5013 static struct hda_input_mux alc260_capture_source = {
5014         .num_items = 4,
5015         .items = {
5016                 { "Mic", 0x0 },
5017                 { "Front Mic", 0x1 },
5018                 { "Line", 0x2 },
5019                 { "CD", 0x4 },
5020         },
5021 };
5022
5023 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5024  * headphone jack and the internal CD lines since these are the only pins at
5025  * which audio can appear.  For flexibility, also allow the option of
5026  * recording the mixer output on the second ADC (ADC0 doesn't have a
5027  * connection to the mixer output).
5028  */
5029 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5030         {
5031                 .num_items = 3,
5032                 .items = {
5033                         { "Mic/Line", 0x0 },
5034                         { "CD", 0x4 },
5035                         { "Headphone", 0x2 },
5036                 },
5037         },
5038         {
5039                 .num_items = 4,
5040                 .items = {
5041                         { "Mic/Line", 0x0 },
5042                         { "CD", 0x4 },
5043                         { "Headphone", 0x2 },
5044                         { "Mixer", 0x5 },
5045                 },
5046         },
5047
5048 };
5049
5050 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5051  * the Fujitsu S702x, but jacks are marked differently.
5052  */
5053 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5054         {
5055                 .num_items = 4,
5056                 .items = {
5057                         { "Mic", 0x0 },
5058                         { "Line", 0x2 },
5059                         { "CD", 0x4 },
5060                         { "Headphone", 0x5 },
5061                 },
5062         },
5063         {
5064                 .num_items = 5,
5065                 .items = {
5066                         { "Mic", 0x0 },
5067                         { "Line", 0x2 },
5068                         { "CD", 0x4 },
5069                         { "Headphone", 0x6 },
5070                         { "Mixer", 0x5 },
5071                 },
5072         },
5073 };
5074
5075 /* Maxdata Favorit 100XS */
5076 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5077         {
5078                 .num_items = 2,
5079                 .items = {
5080                         { "Line/Mic", 0x0 },
5081                         { "CD", 0x4 },
5082                 },
5083         },
5084         {
5085                 .num_items = 3,
5086                 .items = {
5087                         { "Line/Mic", 0x0 },
5088                         { "CD", 0x4 },
5089                         { "Mixer", 0x5 },
5090                 },
5091         },
5092 };
5093
5094 /*
5095  * This is just place-holder, so there's something for alc_build_pcms to look
5096  * at when it calculates the maximum number of channels. ALC260 has no mixer
5097  * element which allows changing the channel mode, so the verb list is
5098  * never used.
5099  */
5100 static struct hda_channel_mode alc260_modes[1] = {
5101         { 2, NULL },
5102 };
5103
5104
5105 /* Mixer combinations
5106  *
5107  * basic: base_output + input + pc_beep + capture
5108  * HP: base_output + input + capture_alt
5109  * HP_3013: hp_3013 + input + capture
5110  * fujitsu: fujitsu + capture
5111  * acer: acer + capture
5112  */
5113
5114 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5115         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5116         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5117         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5118         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5119         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5120         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5121         { } /* end */
5122 };
5123
5124 static struct snd_kcontrol_new alc260_input_mixer[] = {
5125         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5126         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5127         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5128         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5130         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5131         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5132         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5133         { } /* end */
5134 };
5135
5136 /* update HP, line and mono out pins according to the master switch */
5137 static void alc260_hp_master_update(struct hda_codec *codec,
5138                                     hda_nid_t hp, hda_nid_t line,
5139                                     hda_nid_t mono)
5140 {
5141         struct alc_spec *spec = codec->spec;
5142         unsigned int val = spec->master_sw ? PIN_HP : 0;
5143         /* change HP and line-out pins */
5144         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5145                             val);
5146         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5147                             val);
5148         /* mono (speaker) depending on the HP jack sense */
5149         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5150         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5151                             val);
5152 }
5153
5154 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5155                                    struct snd_ctl_elem_value *ucontrol)
5156 {
5157         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5158         struct alc_spec *spec = codec->spec;
5159         *ucontrol->value.integer.value = spec->master_sw;
5160         return 0;
5161 }
5162
5163 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5164                                    struct snd_ctl_elem_value *ucontrol)
5165 {
5166         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5167         struct alc_spec *spec = codec->spec;
5168         int val = !!*ucontrol->value.integer.value;
5169         hda_nid_t hp, line, mono;
5170
5171         if (val == spec->master_sw)
5172                 return 0;
5173         spec->master_sw = val;
5174         hp = (kcontrol->private_value >> 16) & 0xff;
5175         line = (kcontrol->private_value >> 8) & 0xff;
5176         mono = kcontrol->private_value & 0xff;
5177         alc260_hp_master_update(codec, hp, line, mono);
5178         return 1;
5179 }
5180
5181 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5182         {
5183                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5184                 .name = "Master Playback Switch",
5185                 .info = snd_ctl_boolean_mono_info,
5186                 .get = alc260_hp_master_sw_get,
5187                 .put = alc260_hp_master_sw_put,
5188                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5189         },
5190         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5191         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5192         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5193         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5194         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5195                               HDA_OUTPUT),
5196         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5197         { } /* end */
5198 };
5199
5200 static struct hda_verb alc260_hp_unsol_verbs[] = {
5201         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5202         {},
5203 };
5204
5205 static void alc260_hp_automute(struct hda_codec *codec)
5206 {
5207         struct alc_spec *spec = codec->spec;
5208
5209         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5210         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5211 }
5212
5213 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5214 {
5215         if ((res >> 26) == ALC880_HP_EVENT)
5216                 alc260_hp_automute(codec);
5217 }
5218
5219 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5220         {
5221                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5222                 .name = "Master Playback Switch",
5223                 .info = snd_ctl_boolean_mono_info,
5224                 .get = alc260_hp_master_sw_get,
5225                 .put = alc260_hp_master_sw_put,
5226                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5227         },
5228         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5229         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5230         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5231         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5232         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5233         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5234         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5235         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5236         { } /* end */
5237 };
5238
5239 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5240         .ops = &snd_hda_bind_vol,
5241         .values = {
5242                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5243                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5244                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5245                 0
5246         },
5247 };
5248
5249 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5250         .ops = &snd_hda_bind_sw,
5251         .values = {
5252                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5253                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5254                 0
5255         },
5256 };
5257
5258 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5259         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5260         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5261         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5262         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5263         { } /* end */
5264 };
5265
5266 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5267         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5268         {},
5269 };
5270
5271 static void alc260_hp_3013_automute(struct hda_codec *codec)
5272 {
5273         struct alc_spec *spec = codec->spec;
5274
5275         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5276         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5277 }
5278
5279 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5280                                        unsigned int res)
5281 {
5282         if ((res >> 26) == ALC880_HP_EVENT)
5283                 alc260_hp_3013_automute(codec);
5284 }
5285
5286 static void alc260_hp_3012_automute(struct hda_codec *codec)
5287 {
5288         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5289
5290         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5291                             bits);
5292         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5293                             bits);
5294         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5295                             bits);
5296 }
5297
5298 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5299                                        unsigned int res)
5300 {
5301         if ((res >> 26) == ALC880_HP_EVENT)
5302                 alc260_hp_3012_automute(codec);
5303 }
5304
5305 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5306  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5307  */
5308 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5309         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5310         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5311         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5312         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5313         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5314         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5315         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5316         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5317         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5318         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5319         { } /* end */
5320 };
5321
5322 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5323  * versions of the ALC260 don't act on requests to enable mic bias from NID
5324  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5325  * datasheet doesn't mention this restriction.  At this stage it's not clear
5326  * whether this behaviour is intentional or is a hardware bug in chip
5327  * revisions available in early 2006.  Therefore for now allow the
5328  * "Headphone Jack Mode" control to span all choices, but if it turns out
5329  * that the lack of mic bias for this NID is intentional we could change the
5330  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5331  *
5332  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5333  * don't appear to make the mic bias available from the "line" jack, even
5334  * though the NID used for this jack (0x14) can supply it.  The theory is
5335  * that perhaps Acer have included blocking capacitors between the ALC260
5336  * and the output jack.  If this turns out to be the case for all such
5337  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5338  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5339  *
5340  * The C20x Tablet series have a mono internal speaker which is controlled
5341  * via the chip's Mono sum widget and pin complex, so include the necessary
5342  * controls for such models.  On models without a "mono speaker" the control
5343  * won't do anything.
5344  */
5345 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5346         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5347         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5348         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5349         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5350                               HDA_OUTPUT),
5351         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5352                            HDA_INPUT),
5353         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5354         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5355         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5356         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5357         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5358         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5359         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5360         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5361         { } /* end */
5362 };
5363
5364 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5365  */
5366 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5367         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5368         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5369         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5370         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5371         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5372         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5373         { } /* end */
5374 };
5375
5376 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5377  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5378  */
5379 static struct snd_kcontrol_new alc260_will_mixer[] = {
5380         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5381         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5382         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5383         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5384         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5385         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5386         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5387         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5388         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5389         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5390         { } /* end */
5391 };
5392
5393 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5394  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5395  */
5396 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5397         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5398         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5399         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5400         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5401         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5402         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5403         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5404         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5405         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5406         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5407         { } /* end */
5408 };
5409
5410 /*
5411  * initialization verbs
5412  */
5413 static struct hda_verb alc260_init_verbs[] = {
5414         /* Line In pin widget for input */
5415         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5416         /* CD pin widget for input */
5417         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5418         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5419         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5420         /* Mic2 (front panel) pin widget for input and vref at 80% */
5421         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5422         /* LINE-2 is used for line-out in rear */
5423         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5424         /* select line-out */
5425         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5426         /* LINE-OUT pin */
5427         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5428         /* enable HP */
5429         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5430         /* enable Mono */
5431         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5432         /* mute capture amp left and right */
5433         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5434         /* set connection select to line in (default select for this ADC) */
5435         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5436         /* mute capture amp left and right */
5437         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5438         /* set connection select to line in (default select for this ADC) */
5439         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5440         /* set vol=0 Line-Out mixer amp left and right */
5441         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5442         /* unmute pin widget amp left and right (no gain on this amp) */
5443         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5444         /* set vol=0 HP mixer amp left and right */
5445         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5446         /* unmute pin widget amp left and right (no gain on this amp) */
5447         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5448         /* set vol=0 Mono mixer amp left and right */
5449         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5450         /* unmute pin widget amp left and right (no gain on this amp) */
5451         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5452         /* unmute LINE-2 out pin */
5453         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5454         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5455          * Line In 2 = 0x03
5456          */
5457         /* mute analog inputs */
5458         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5459         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5460         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5461         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5462         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5463         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5464         /* mute Front out path */
5465         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5466         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5467         /* mute Headphone out path */
5468         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5469         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5470         /* mute Mono out path */
5471         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5472         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5473         { }
5474 };
5475
5476 #if 0 /* should be identical with alc260_init_verbs? */
5477 static struct hda_verb alc260_hp_init_verbs[] = {
5478         /* Headphone and output */
5479         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5480         /* mono output */
5481         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5482         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5483         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5484         /* Mic2 (front panel) pin widget for input and vref at 80% */
5485         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5486         /* Line In pin widget for input */
5487         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5488         /* Line-2 pin widget for output */
5489         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5490         /* CD pin widget for input */
5491         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5492         /* unmute amp left and right */
5493         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5494         /* set connection select to line in (default select for this ADC) */
5495         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5496         /* unmute Line-Out mixer amp left and right (volume = 0) */
5497         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5498         /* mute pin widget amp left and right (no gain on this amp) */
5499         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5500         /* unmute HP mixer amp left and right (volume = 0) */
5501         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5502         /* mute pin widget amp left and right (no gain on this amp) */
5503         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5504         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5505          * Line In 2 = 0x03
5506          */
5507         /* mute analog inputs */
5508         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5509         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5510         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5511         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5512         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5513         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5514         /* Unmute Front out path */
5515         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5516         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5517         /* Unmute Headphone out path */
5518         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5519         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5520         /* Unmute Mono out path */
5521         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5522         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5523         { }
5524 };
5525 #endif
5526
5527 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5528         /* Line out and output */
5529         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5530         /* mono output */
5531         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5532         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5533         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5534         /* Mic2 (front panel) pin widget for input and vref at 80% */
5535         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5536         /* Line In pin widget for input */
5537         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5538         /* Headphone pin widget for output */
5539         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5540         /* CD pin widget for input */
5541         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5542         /* unmute amp left and right */
5543         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5544         /* set connection select to line in (default select for this ADC) */
5545         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5546         /* unmute Line-Out mixer amp left and right (volume = 0) */
5547         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5548         /* mute pin widget amp left and right (no gain on this amp) */
5549         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5550         /* unmute HP mixer amp left and right (volume = 0) */
5551         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5552         /* mute pin widget amp left and right (no gain on this amp) */
5553         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5554         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5555          * Line In 2 = 0x03
5556          */
5557         /* mute analog inputs */
5558         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5559         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5560         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5561         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5562         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5563         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5564         /* Unmute Front out path */
5565         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5566         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5567         /* Unmute Headphone out path */
5568         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5569         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5570         /* Unmute Mono out path */
5571         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5572         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5573         { }
5574 };
5575
5576 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5577  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5578  * audio = 0x16, internal speaker = 0x10.
5579  */
5580 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5581         /* Disable all GPIOs */
5582         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5583         /* Internal speaker is connected to headphone pin */
5584         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5585         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5586         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5587         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5588         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5589         /* Ensure all other unused pins are disabled and muted. */
5590         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5591         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5592         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5593         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5594         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5595         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5596         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5597         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5598
5599         /* Disable digital (SPDIF) pins */
5600         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5601         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5602
5603         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5604          * when acting as an output.
5605          */
5606         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5607
5608         /* Start with output sum widgets muted and their output gains at min */
5609         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5610         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5611         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5612         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5613         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5614         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5615         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5616         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5617         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5618
5619         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5620         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5621         /* Unmute Line1 pin widget output buffer since it starts as an output.
5622          * If the pin mode is changed by the user the pin mode control will
5623          * take care of enabling the pin's input/output buffers as needed.
5624          * Therefore there's no need to enable the input buffer at this
5625          * stage.
5626          */
5627         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5628         /* Unmute input buffer of pin widget used for Line-in (no equiv
5629          * mixer ctrl)
5630          */
5631         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5632
5633         /* Mute capture amp left and right */
5634         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5635         /* Set ADC connection select to match default mixer setting - line
5636          * in (on mic1 pin)
5637          */
5638         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5639
5640         /* Do the same for the second ADC: mute capture input amp and
5641          * set ADC connection to line in (on mic1 pin)
5642          */
5643         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5644         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5645
5646         /* Mute all inputs to mixer widget (even unconnected ones) */
5647         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5648         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5649         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5650         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5651         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5652         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5653         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5654         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5655
5656         { }
5657 };
5658
5659 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5660  * similar laptops (adapted from Fujitsu init verbs).
5661  */
5662 static struct hda_verb alc260_acer_init_verbs[] = {
5663         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5664          * the headphone jack.  Turn this on and rely on the standard mute
5665          * methods whenever the user wants to turn these outputs off.
5666          */
5667         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5668         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5669         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5670         /* Internal speaker/Headphone jack is connected to Line-out pin */
5671         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5672         /* Internal microphone/Mic jack is connected to Mic1 pin */
5673         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5674         /* Line In jack is connected to Line1 pin */
5675         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5676         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5677         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5678         /* Ensure all other unused pins are disabled and muted. */
5679         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5680         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5681         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5682         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5683         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5684         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5685         /* Disable digital (SPDIF) pins */
5686         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5687         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5688
5689         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5690          * bus when acting as outputs.
5691          */
5692         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5693         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5694
5695         /* Start with output sum widgets muted and their output gains at min */
5696         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5697         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5698         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5699         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5700         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5701         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5702         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5703         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5704         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5705
5706         /* Unmute Line-out pin widget amp left and right
5707          * (no equiv mixer ctrl)
5708          */
5709         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5710         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5711         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5712         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5713          * inputs. If the pin mode is changed by the user the pin mode control
5714          * will take care of enabling the pin's input/output buffers as needed.
5715          * Therefore there's no need to enable the input buffer at this
5716          * stage.
5717          */
5718         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5719         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5720
5721         /* Mute capture amp left and right */
5722         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5723         /* Set ADC connection select to match default mixer setting - mic
5724          * (on mic1 pin)
5725          */
5726         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5727
5728         /* Do similar with the second ADC: mute capture input amp and
5729          * set ADC connection to mic to match ALSA's default state.
5730          */
5731         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5732         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5733
5734         /* Mute all inputs to mixer widget (even unconnected ones) */
5735         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5736         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5737         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5738         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5739         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5740         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5741         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5742         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5743
5744         { }
5745 };
5746
5747 /* Initialisation sequence for Maxdata Favorit 100XS
5748  * (adapted from Acer init verbs).
5749  */
5750 static struct hda_verb alc260_favorit100_init_verbs[] = {
5751         /* GPIO 0 enables the output jack.
5752          * Turn this on and rely on the standard mute
5753          * methods whenever the user wants to turn these outputs off.
5754          */
5755         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5756         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5757         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5758         /* Line/Mic input jack is connected to Mic1 pin */
5759         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5760         /* Ensure all other unused pins are disabled and muted. */
5761         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5762         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5763         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5764         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5765         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5766         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5767         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5768         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5769         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5770         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5771         /* Disable digital (SPDIF) pins */
5772         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5773         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5774
5775         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5776          * bus when acting as outputs.
5777          */
5778         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5779         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5780
5781         /* Start with output sum widgets muted and their output gains at min */
5782         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5783         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5784         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5785         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5786         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5787         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5788         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5789         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5790         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5791
5792         /* Unmute Line-out pin widget amp left and right
5793          * (no equiv mixer ctrl)
5794          */
5795         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5796         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5797          * inputs. If the pin mode is changed by the user the pin mode control
5798          * will take care of enabling the pin's input/output buffers as needed.
5799          * Therefore there's no need to enable the input buffer at this
5800          * stage.
5801          */
5802         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5803
5804         /* Mute capture amp left and right */
5805         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5806         /* Set ADC connection select to match default mixer setting - mic
5807          * (on mic1 pin)
5808          */
5809         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5810
5811         /* Do similar with the second ADC: mute capture input amp and
5812          * set ADC connection to mic to match ALSA's default state.
5813          */
5814         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5815         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5816
5817         /* Mute all inputs to mixer widget (even unconnected ones) */
5818         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5819         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5820         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5821         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5822         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5823         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5824         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5825         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5826
5827         { }
5828 };
5829
5830 static struct hda_verb alc260_will_verbs[] = {
5831         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5832         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5833         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5834         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5835         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5836         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5837         {}
5838 };
5839
5840 static struct hda_verb alc260_replacer_672v_verbs[] = {
5841         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5842         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5843         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5844
5845         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5846         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5847         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5848
5849         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5850         {}
5851 };
5852
5853 /* toggle speaker-output according to the hp-jack state */
5854 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5855 {
5856         unsigned int present;
5857
5858         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5859         present = snd_hda_jack_detect(codec, 0x0f);
5860         if (present) {
5861                 snd_hda_codec_write_cache(codec, 0x01, 0,
5862                                           AC_VERB_SET_GPIO_DATA, 1);
5863                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5864                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5865                                           PIN_HP);
5866         } else {
5867                 snd_hda_codec_write_cache(codec, 0x01, 0,
5868                                           AC_VERB_SET_GPIO_DATA, 0);
5869                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5870                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5871                                           PIN_OUT);
5872         }
5873 }
5874
5875 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5876                                        unsigned int res)
5877 {
5878         if ((res >> 26) == ALC880_HP_EVENT)
5879                 alc260_replacer_672v_automute(codec);
5880 }
5881
5882 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5883         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5884         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5885         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5886         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5887         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5888         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5889         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5890         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5891         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5892         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5893         {}
5894 };
5895
5896 /* Test configuration for debugging, modelled after the ALC880 test
5897  * configuration.
5898  */
5899 #ifdef CONFIG_SND_DEBUG
5900 static hda_nid_t alc260_test_dac_nids[1] = {
5901         0x02,
5902 };
5903 static hda_nid_t alc260_test_adc_nids[2] = {
5904         0x04, 0x05,
5905 };
5906 /* For testing the ALC260, each input MUX needs its own definition since
5907  * the signal assignments are different.  This assumes that the first ADC
5908  * is NID 0x04.
5909  */
5910 static struct hda_input_mux alc260_test_capture_sources[2] = {
5911         {
5912                 .num_items = 7,
5913                 .items = {
5914                         { "MIC1 pin", 0x0 },
5915                         { "MIC2 pin", 0x1 },
5916                         { "LINE1 pin", 0x2 },
5917                         { "LINE2 pin", 0x3 },
5918                         { "CD pin", 0x4 },
5919                         { "LINE-OUT pin", 0x5 },
5920                         { "HP-OUT pin", 0x6 },
5921                 },
5922         },
5923         {
5924                 .num_items = 8,
5925                 .items = {
5926                         { "MIC1 pin", 0x0 },
5927                         { "MIC2 pin", 0x1 },
5928                         { "LINE1 pin", 0x2 },
5929                         { "LINE2 pin", 0x3 },
5930                         { "CD pin", 0x4 },
5931                         { "Mixer", 0x5 },
5932                         { "LINE-OUT pin", 0x6 },
5933                         { "HP-OUT pin", 0x7 },
5934                 },
5935         },
5936 };
5937 static struct snd_kcontrol_new alc260_test_mixer[] = {
5938         /* Output driver widgets */
5939         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5940         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5941         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5942         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5943         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5944         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5945
5946         /* Modes for retasking pin widgets
5947          * Note: the ALC260 doesn't seem to act on requests to enable mic
5948          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5949          * mention this restriction.  At this stage it's not clear whether
5950          * this behaviour is intentional or is a hardware bug in chip
5951          * revisions available at least up until early 2006.  Therefore for
5952          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5953          * choices, but if it turns out that the lack of mic bias for these
5954          * NIDs is intentional we could change their modes from
5955          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5956          */
5957         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5958         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5959         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5960         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5961         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5962         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5963
5964         /* Loopback mixer controls */
5965         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5966         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5967         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5968         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5969         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5970         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5971         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5972         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5973         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5974         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5975         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5976         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5977         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5978         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5979
5980         /* Controls for GPIO pins, assuming they are configured as outputs */
5981         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5982         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5983         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5984         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5985
5986         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5987          * is ambigious as to which NID is which; testing on laptops which
5988          * make this output available should provide clarification.
5989          */
5990         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5991         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5992
5993         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5994          * this output to turn on an external amplifier.
5995          */
5996         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5997         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5998
5999         { } /* end */
6000 };
6001 static struct hda_verb alc260_test_init_verbs[] = {
6002         /* Enable all GPIOs as outputs with an initial value of 0 */
6003         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6004         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6005         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6006
6007         /* Enable retasking pins as output, initially without power amp */
6008         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6009         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6010         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6011         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6012         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6013         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6014
6015         /* Disable digital (SPDIF) pins initially, but users can enable
6016          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6017          * payload also sets the generation to 0, output to be in "consumer"
6018          * PCM format, copyright asserted, no pre-emphasis and no validity
6019          * control.
6020          */
6021         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6022         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6023
6024         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6025          * OUT1 sum bus when acting as an output.
6026          */
6027         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6028         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6029         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6030         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6031
6032         /* Start with output sum widgets muted and their output gains at min */
6033         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6034         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6035         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6036         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6037         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6038         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6039         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6040         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6041         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6042
6043         /* Unmute retasking pin widget output buffers since the default
6044          * state appears to be output.  As the pin mode is changed by the
6045          * user the pin mode control will take care of enabling the pin's
6046          * input/output buffers as needed.
6047          */
6048         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6049         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6050         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6051         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6052         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6053         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6054         /* Also unmute the mono-out pin widget */
6055         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6056
6057         /* Mute capture amp left and right */
6058         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6059         /* Set ADC connection select to match default mixer setting (mic1
6060          * pin)
6061          */
6062         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6063
6064         /* Do the same for the second ADC: mute capture input amp and
6065          * set ADC connection to mic1 pin
6066          */
6067         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6068         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6069
6070         /* Mute all inputs to mixer widget (even unconnected ones) */
6071         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6072         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6073         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6074         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6075         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6076         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6077         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6078         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6079
6080         { }
6081 };
6082 #endif
6083
6084 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6085 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6086
6087 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6088 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6089
6090 /*
6091  * for BIOS auto-configuration
6092  */
6093
6094 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6095                                         const char *pfx, int *vol_bits)
6096 {
6097         hda_nid_t nid_vol;
6098         unsigned long vol_val, sw_val;
6099         int err;
6100
6101         if (nid >= 0x0f && nid < 0x11) {
6102                 nid_vol = nid - 0x7;
6103                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6104                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6105         } else if (nid == 0x11) {
6106                 nid_vol = nid - 0x7;
6107                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6108                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6109         } else if (nid >= 0x12 && nid <= 0x15) {
6110                 nid_vol = 0x08;
6111                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6112                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6113         } else
6114                 return 0; /* N/A */
6115
6116         if (!(*vol_bits & (1 << nid_vol))) {
6117                 /* first control for the volume widget */
6118                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6119                 if (err < 0)
6120                         return err;
6121                 *vol_bits |= (1 << nid_vol);
6122         }
6123         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6124         if (err < 0)
6125                 return err;
6126         return 1;
6127 }
6128
6129 /* add playback controls from the parsed DAC table */
6130 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6131                                              const struct auto_pin_cfg *cfg)
6132 {
6133         hda_nid_t nid;
6134         int err;
6135         int vols = 0;
6136
6137         spec->multiout.num_dacs = 1;
6138         spec->multiout.dac_nids = spec->private_dac_nids;
6139         spec->multiout.dac_nids[0] = 0x02;
6140
6141         nid = cfg->line_out_pins[0];
6142         if (nid) {
6143                 const char *pfx;
6144                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6145                         pfx = "Master";
6146                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6147                         pfx = "Speaker";
6148                 else
6149                         pfx = "Front";
6150                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6151                 if (err < 0)
6152                         return err;
6153         }
6154
6155         nid = cfg->speaker_pins[0];
6156         if (nid) {
6157                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6158                 if (err < 0)
6159                         return err;
6160         }
6161
6162         nid = cfg->hp_pins[0];
6163         if (nid) {
6164                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6165                                                    &vols);
6166                 if (err < 0)
6167                         return err;
6168         }
6169         return 0;
6170 }
6171
6172 /* create playback/capture controls for input pins */
6173 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6174                                                 const struct auto_pin_cfg *cfg)
6175 {
6176         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6177 }
6178
6179 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6180                                               hda_nid_t nid, int pin_type,
6181                                               int sel_idx)
6182 {
6183         alc_set_pin_output(codec, nid, pin_type);
6184         /* need the manual connection? */
6185         if (nid >= 0x12) {
6186                 int idx = nid - 0x12;
6187                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6188                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6189         }
6190 }
6191
6192 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6193 {
6194         struct alc_spec *spec = codec->spec;
6195         hda_nid_t nid;
6196
6197         nid = spec->autocfg.line_out_pins[0];
6198         if (nid) {
6199                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6200                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6201         }
6202
6203         nid = spec->autocfg.speaker_pins[0];
6204         if (nid)
6205                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6206
6207         nid = spec->autocfg.hp_pins[0];
6208         if (nid)
6209                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6210 }
6211
6212 #define ALC260_PIN_CD_NID               0x16
6213 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6214 {
6215         struct alc_spec *spec = codec->spec;
6216         int i;
6217
6218         for (i = 0; i < AUTO_PIN_LAST; i++) {
6219                 hda_nid_t nid = spec->autocfg.input_pins[i];
6220                 if (nid >= 0x12) {
6221                         alc_set_input_pin(codec, nid, i);
6222                         if (nid != ALC260_PIN_CD_NID &&
6223                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6224                                 snd_hda_codec_write(codec, nid, 0,
6225                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6226                                                     AMP_OUT_MUTE);
6227                 }
6228         }
6229 }
6230
6231 /*
6232  * generic initialization of ADC, input mixers and output mixers
6233  */
6234 static struct hda_verb alc260_volume_init_verbs[] = {
6235         /*
6236          * Unmute ADC0-1 and set the default input to mic-in
6237          */
6238         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6239         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6240         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6241         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6242
6243         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6244          * mixer widget
6245          * Note: PASD motherboards uses the Line In 2 as the input for
6246          * front panel mic (mic 2)
6247          */
6248         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6249         /* mute analog inputs */
6250         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6251         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6252         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6253         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6254         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6255
6256         /*
6257          * Set up output mixers (0x08 - 0x0a)
6258          */
6259         /* set vol=0 to output mixers */
6260         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6261         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6262         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6263         /* set up input amps for analog loopback */
6264         /* Amp Indices: DAC = 0, mixer = 1 */
6265         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6266         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6267         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6268         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6269         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6270         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6271
6272         { }
6273 };
6274
6275 static int alc260_parse_auto_config(struct hda_codec *codec)
6276 {
6277         struct alc_spec *spec = codec->spec;
6278         int err;
6279         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6280
6281         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6282                                            alc260_ignore);
6283         if (err < 0)
6284                 return err;
6285         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6286         if (err < 0)
6287                 return err;
6288         if (!spec->kctls.list)
6289                 return 0; /* can't find valid BIOS pin config */
6290         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6291         if (err < 0)
6292                 return err;
6293
6294         spec->multiout.max_channels = 2;
6295
6296         if (spec->autocfg.dig_outs)
6297                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6298         if (spec->kctls.list)
6299                 add_mixer(spec, spec->kctls.list);
6300
6301         add_verb(spec, alc260_volume_init_verbs);
6302
6303         spec->num_mux_defs = 1;
6304         spec->input_mux = &spec->private_imux[0];
6305
6306         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6307
6308         return 1;
6309 }
6310
6311 /* additional initialization for auto-configuration model */
6312 static void alc260_auto_init(struct hda_codec *codec)
6313 {
6314         struct alc_spec *spec = codec->spec;
6315         alc260_auto_init_multi_out(codec);
6316         alc260_auto_init_analog_input(codec);
6317         if (spec->unsol_event)
6318                 alc_inithook(codec);
6319 }
6320
6321 #ifdef CONFIG_SND_HDA_POWER_SAVE
6322 static struct hda_amp_list alc260_loopbacks[] = {
6323         { 0x07, HDA_INPUT, 0 },
6324         { 0x07, HDA_INPUT, 1 },
6325         { 0x07, HDA_INPUT, 2 },
6326         { 0x07, HDA_INPUT, 3 },
6327         { 0x07, HDA_INPUT, 4 },
6328         { } /* end */
6329 };
6330 #endif
6331
6332 /*
6333  * ALC260 configurations
6334  */
6335 static const char *alc260_models[ALC260_MODEL_LAST] = {
6336         [ALC260_BASIC]          = "basic",
6337         [ALC260_HP]             = "hp",
6338         [ALC260_HP_3013]        = "hp-3013",
6339         [ALC260_HP_DC7600]      = "hp-dc7600",
6340         [ALC260_FUJITSU_S702X]  = "fujitsu",
6341         [ALC260_ACER]           = "acer",
6342         [ALC260_WILL]           = "will",
6343         [ALC260_REPLACER_672V]  = "replacer",
6344         [ALC260_FAVORIT100]     = "favorit100",
6345 #ifdef CONFIG_SND_DEBUG
6346         [ALC260_TEST]           = "test",
6347 #endif
6348         [ALC260_AUTO]           = "auto",
6349 };
6350
6351 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6352         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6353         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6354         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6355         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6356         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6357         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6358         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6359         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6360         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6361         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6362         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6363         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6364         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6365         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6366         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6367         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6368         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6369         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6370         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6371         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6372         {}
6373 };
6374
6375 static struct alc_config_preset alc260_presets[] = {
6376         [ALC260_BASIC] = {
6377                 .mixers = { alc260_base_output_mixer,
6378                             alc260_input_mixer },
6379                 .init_verbs = { alc260_init_verbs },
6380                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6381                 .dac_nids = alc260_dac_nids,
6382                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6383                 .adc_nids = alc260_adc_nids,
6384                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6385                 .channel_mode = alc260_modes,
6386                 .input_mux = &alc260_capture_source,
6387         },
6388         [ALC260_HP] = {
6389                 .mixers = { alc260_hp_output_mixer,
6390                             alc260_input_mixer },
6391                 .init_verbs = { alc260_init_verbs,
6392                                 alc260_hp_unsol_verbs },
6393                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6394                 .dac_nids = alc260_dac_nids,
6395                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6396                 .adc_nids = alc260_adc_nids_alt,
6397                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6398                 .channel_mode = alc260_modes,
6399                 .input_mux = &alc260_capture_source,
6400                 .unsol_event = alc260_hp_unsol_event,
6401                 .init_hook = alc260_hp_automute,
6402         },
6403         [ALC260_HP_DC7600] = {
6404                 .mixers = { alc260_hp_dc7600_mixer,
6405                             alc260_input_mixer },
6406                 .init_verbs = { alc260_init_verbs,
6407                                 alc260_hp_dc7600_verbs },
6408                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6409                 .dac_nids = alc260_dac_nids,
6410                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6411                 .adc_nids = alc260_adc_nids_alt,
6412                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6413                 .channel_mode = alc260_modes,
6414                 .input_mux = &alc260_capture_source,
6415                 .unsol_event = alc260_hp_3012_unsol_event,
6416                 .init_hook = alc260_hp_3012_automute,
6417         },
6418         [ALC260_HP_3013] = {
6419                 .mixers = { alc260_hp_3013_mixer,
6420                             alc260_input_mixer },
6421                 .init_verbs = { alc260_hp_3013_init_verbs,
6422                                 alc260_hp_3013_unsol_verbs },
6423                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6424                 .dac_nids = alc260_dac_nids,
6425                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6426                 .adc_nids = alc260_adc_nids_alt,
6427                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6428                 .channel_mode = alc260_modes,
6429                 .input_mux = &alc260_capture_source,
6430                 .unsol_event = alc260_hp_3013_unsol_event,
6431                 .init_hook = alc260_hp_3013_automute,
6432         },
6433         [ALC260_FUJITSU_S702X] = {
6434                 .mixers = { alc260_fujitsu_mixer },
6435                 .init_verbs = { alc260_fujitsu_init_verbs },
6436                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6437                 .dac_nids = alc260_dac_nids,
6438                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6439                 .adc_nids = alc260_dual_adc_nids,
6440                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6441                 .channel_mode = alc260_modes,
6442                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6443                 .input_mux = alc260_fujitsu_capture_sources,
6444         },
6445         [ALC260_ACER] = {
6446                 .mixers = { alc260_acer_mixer },
6447                 .init_verbs = { alc260_acer_init_verbs },
6448                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6449                 .dac_nids = alc260_dac_nids,
6450                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6451                 .adc_nids = alc260_dual_adc_nids,
6452                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6453                 .channel_mode = alc260_modes,
6454                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6455                 .input_mux = alc260_acer_capture_sources,
6456         },
6457         [ALC260_FAVORIT100] = {
6458                 .mixers = { alc260_favorit100_mixer },
6459                 .init_verbs = { alc260_favorit100_init_verbs },
6460                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6461                 .dac_nids = alc260_dac_nids,
6462                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6463                 .adc_nids = alc260_dual_adc_nids,
6464                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6465                 .channel_mode = alc260_modes,
6466                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6467                 .input_mux = alc260_favorit100_capture_sources,
6468         },
6469         [ALC260_WILL] = {
6470                 .mixers = { alc260_will_mixer },
6471                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6472                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6473                 .dac_nids = alc260_dac_nids,
6474                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6475                 .adc_nids = alc260_adc_nids,
6476                 .dig_out_nid = ALC260_DIGOUT_NID,
6477                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6478                 .channel_mode = alc260_modes,
6479                 .input_mux = &alc260_capture_source,
6480         },
6481         [ALC260_REPLACER_672V] = {
6482                 .mixers = { alc260_replacer_672v_mixer },
6483                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6484                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6485                 .dac_nids = alc260_dac_nids,
6486                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6487                 .adc_nids = alc260_adc_nids,
6488                 .dig_out_nid = ALC260_DIGOUT_NID,
6489                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6490                 .channel_mode = alc260_modes,
6491                 .input_mux = &alc260_capture_source,
6492                 .unsol_event = alc260_replacer_672v_unsol_event,
6493                 .init_hook = alc260_replacer_672v_automute,
6494         },
6495 #ifdef CONFIG_SND_DEBUG
6496         [ALC260_TEST] = {
6497                 .mixers = { alc260_test_mixer },
6498                 .init_verbs = { alc260_test_init_verbs },
6499                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6500                 .dac_nids = alc260_test_dac_nids,
6501                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6502                 .adc_nids = alc260_test_adc_nids,
6503                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6504                 .channel_mode = alc260_modes,
6505                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6506                 .input_mux = alc260_test_capture_sources,
6507         },
6508 #endif
6509 };
6510
6511 static int patch_alc260(struct hda_codec *codec)
6512 {
6513         struct alc_spec *spec;
6514         int err, board_config;
6515
6516         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6517         if (spec == NULL)
6518                 return -ENOMEM;
6519
6520         codec->spec = spec;
6521
6522         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6523                                                   alc260_models,
6524                                                   alc260_cfg_tbl);
6525         if (board_config < 0) {
6526                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6527                            codec->chip_name);
6528                 board_config = ALC260_AUTO;
6529         }
6530
6531         if (board_config == ALC260_AUTO) {
6532                 /* automatic parse from the BIOS config */
6533                 err = alc260_parse_auto_config(codec);
6534                 if (err < 0) {
6535                         alc_free(codec);
6536                         return err;
6537                 } else if (!err) {
6538                         printk(KERN_INFO
6539                                "hda_codec: Cannot set up configuration "
6540                                "from BIOS.  Using base mode...\n");
6541                         board_config = ALC260_BASIC;
6542                 }
6543         }
6544
6545         err = snd_hda_attach_beep_device(codec, 0x1);
6546         if (err < 0) {
6547                 alc_free(codec);
6548                 return err;
6549         }
6550
6551         if (board_config != ALC260_AUTO)
6552                 setup_preset(codec, &alc260_presets[board_config]);
6553
6554         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6555         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6556
6557         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6558         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6559
6560         if (!spec->adc_nids && spec->input_mux) {
6561                 /* check whether NID 0x04 is valid */
6562                 unsigned int wcap = get_wcaps(codec, 0x04);
6563                 wcap = get_wcaps_type(wcap);
6564                 /* get type */
6565                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6566                         spec->adc_nids = alc260_adc_nids_alt;
6567                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6568                 } else {
6569                         spec->adc_nids = alc260_adc_nids;
6570                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6571                 }
6572         }
6573         set_capture_mixer(codec);
6574         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6575
6576         spec->vmaster_nid = 0x08;
6577
6578         codec->patch_ops = alc_patch_ops;
6579         if (board_config == ALC260_AUTO)
6580                 spec->init_hook = alc260_auto_init;
6581 #ifdef CONFIG_SND_HDA_POWER_SAVE
6582         if (!spec->loopback.amplist)
6583                 spec->loopback.amplist = alc260_loopbacks;
6584 #endif
6585         codec->proc_widget_hook = print_realtek_coef;
6586
6587         return 0;
6588 }
6589
6590
6591 /*
6592  * ALC882/883/885/888/889 support
6593  *
6594  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6595  * configuration.  Each pin widget can choose any input DACs and a mixer.
6596  * Each ADC is connected from a mixer of all inputs.  This makes possible
6597  * 6-channel independent captures.
6598  *
6599  * In addition, an independent DAC for the multi-playback (not used in this
6600  * driver yet).
6601  */
6602 #define ALC882_DIGOUT_NID       0x06
6603 #define ALC882_DIGIN_NID        0x0a
6604 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6605 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6606 #define ALC1200_DIGOUT_NID      0x10
6607
6608
6609 static struct hda_channel_mode alc882_ch_modes[1] = {
6610         { 8, NULL }
6611 };
6612
6613 /* DACs */
6614 static hda_nid_t alc882_dac_nids[4] = {
6615         /* front, rear, clfe, rear_surr */
6616         0x02, 0x03, 0x04, 0x05
6617 };
6618 #define alc883_dac_nids         alc882_dac_nids
6619
6620 /* ADCs */
6621 #define alc882_adc_nids         alc880_adc_nids
6622 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6623 #define alc883_adc_nids         alc882_adc_nids_alt
6624 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6625 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6626 #define alc889_adc_nids         alc880_adc_nids
6627
6628 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6629 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6630 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6631 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6632 #define alc889_capsrc_nids      alc882_capsrc_nids
6633
6634 /* input MUX */
6635 /* FIXME: should be a matrix-type input source selection */
6636
6637 static struct hda_input_mux alc882_capture_source = {
6638         .num_items = 4,
6639         .items = {
6640                 { "Mic", 0x0 },
6641                 { "Front Mic", 0x1 },
6642                 { "Line", 0x2 },
6643                 { "CD", 0x4 },
6644         },
6645 };
6646
6647 #define alc883_capture_source   alc882_capture_source
6648
6649 static struct hda_input_mux alc889_capture_source = {
6650         .num_items = 3,
6651         .items = {
6652                 { "Front Mic", 0x0 },
6653                 { "Mic", 0x3 },
6654                 { "Line", 0x2 },
6655         },
6656 };
6657
6658 static struct hda_input_mux mb5_capture_source = {
6659         .num_items = 3,
6660         .items = {
6661                 { "Mic", 0x1 },
6662                 { "Line", 0x2 },
6663                 { "CD", 0x4 },
6664         },
6665 };
6666
6667 static struct hda_input_mux alc883_3stack_6ch_intel = {
6668         .num_items = 4,
6669         .items = {
6670                 { "Mic", 0x1 },
6671                 { "Front Mic", 0x0 },
6672                 { "Line", 0x2 },
6673                 { "CD", 0x4 },
6674         },
6675 };
6676
6677 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6678         .num_items = 2,
6679         .items = {
6680                 { "Mic", 0x1 },
6681                 { "Line", 0x2 },
6682         },
6683 };
6684
6685 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6686         .num_items = 4,
6687         .items = {
6688                 { "Mic", 0x0 },
6689                 { "iMic", 0x1 },
6690                 { "Line", 0x2 },
6691                 { "CD", 0x4 },
6692         },
6693 };
6694
6695 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6696         .num_items = 2,
6697         .items = {
6698                 { "Mic", 0x0 },
6699                 { "Int Mic", 0x1 },
6700         },
6701 };
6702
6703 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6704         .num_items = 3,
6705         .items = {
6706                 { "Mic", 0x0 },
6707                 { "Front Mic", 0x1 },
6708                 { "Line", 0x4 },
6709         },
6710 };
6711
6712 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6713         .num_items = 2,
6714         .items = {
6715                 { "Mic", 0x0 },
6716                 { "Line", 0x2 },
6717         },
6718 };
6719
6720 static struct hda_input_mux alc889A_mb31_capture_source = {
6721         .num_items = 2,
6722         .items = {
6723                 { "Mic", 0x0 },
6724                 /* Front Mic (0x01) unused */
6725                 { "Line", 0x2 },
6726                 /* Line 2 (0x03) unused */
6727                 /* CD (0x04) unused? */
6728         },
6729 };
6730
6731 /*
6732  * 2ch mode
6733  */
6734 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6735         { 2, NULL }
6736 };
6737
6738 /*
6739  * 2ch mode
6740  */
6741 static struct hda_verb alc882_3ST_ch2_init[] = {
6742         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6743         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6744         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6745         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6746         { } /* end */
6747 };
6748
6749 /*
6750  * 4ch mode
6751  */
6752 static struct hda_verb alc882_3ST_ch4_init[] = {
6753         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6754         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6755         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6756         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6757         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6758         { } /* end */
6759 };
6760
6761 /*
6762  * 6ch mode
6763  */
6764 static struct hda_verb alc882_3ST_ch6_init[] = {
6765         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6766         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6767         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6768         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6769         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6770         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6771         { } /* end */
6772 };
6773
6774 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6775         { 2, alc882_3ST_ch2_init },
6776         { 4, alc882_3ST_ch4_init },
6777         { 6, alc882_3ST_ch6_init },
6778 };
6779
6780 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6781
6782 /*
6783  * 2ch mode
6784  */
6785 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6786         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6787         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6788         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6789         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6790         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6791         { } /* end */
6792 };
6793
6794 /*
6795  * 4ch mode
6796  */
6797 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6798         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6799         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6800         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6801         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6802         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6803         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6804         { } /* end */
6805 };
6806
6807 /*
6808  * 6ch mode
6809  */
6810 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6811         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6812         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6813         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6814         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6815         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6816         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6817         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6818         { } /* end */
6819 };
6820
6821 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6822         { 2, alc883_3ST_ch2_clevo_init },
6823         { 4, alc883_3ST_ch4_clevo_init },
6824         { 6, alc883_3ST_ch6_clevo_init },
6825 };
6826
6827
6828 /*
6829  * 6ch mode
6830  */
6831 static struct hda_verb alc882_sixstack_ch6_init[] = {
6832         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6833         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6834         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6835         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6836         { } /* end */
6837 };
6838
6839 /*
6840  * 8ch mode
6841  */
6842 static struct hda_verb alc882_sixstack_ch8_init[] = {
6843         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6844         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6845         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6846         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6847         { } /* end */
6848 };
6849
6850 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6851         { 6, alc882_sixstack_ch6_init },
6852         { 8, alc882_sixstack_ch8_init },
6853 };
6854
6855 /*
6856  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6857  */
6858
6859 /*
6860  * 2ch mode
6861  */
6862 static struct hda_verb alc885_mbp_ch2_init[] = {
6863         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6864         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6865         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6866         { } /* end */
6867 };
6868
6869 /*
6870  * 4ch mode
6871  */
6872 static struct hda_verb alc885_mbp_ch4_init[] = {
6873         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6874         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6875         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6876         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6877         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6878         { } /* end */
6879 };
6880
6881 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
6882         { 2, alc885_mbp_ch2_init },
6883         { 4, alc885_mbp_ch4_init },
6884 };
6885
6886 /*
6887  * 2ch
6888  * Speakers/Woofer/HP = Front
6889  * LineIn = Input
6890  */
6891 static struct hda_verb alc885_mb5_ch2_init[] = {
6892         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6893         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6894         { } /* end */
6895 };
6896
6897 /*
6898  * 6ch mode
6899  * Speakers/HP = Front
6900  * Woofer = LFE
6901  * LineIn = Surround
6902  */
6903 static struct hda_verb alc885_mb5_ch6_init[] = {
6904         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6905         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6906         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6907         { } /* end */
6908 };
6909
6910 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6911         { 2, alc885_mb5_ch2_init },
6912         { 6, alc885_mb5_ch6_init },
6913 };
6914
6915
6916 /*
6917  * 2ch mode
6918  */
6919 static struct hda_verb alc883_4ST_ch2_init[] = {
6920         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6921         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6922         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6923         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6924         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6925         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6926         { } /* end */
6927 };
6928
6929 /*
6930  * 4ch mode
6931  */
6932 static struct hda_verb alc883_4ST_ch4_init[] = {
6933         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6934         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6935         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6936         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6937         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6938         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6939         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6940         { } /* end */
6941 };
6942
6943 /*
6944  * 6ch mode
6945  */
6946 static struct hda_verb alc883_4ST_ch6_init[] = {
6947         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6948         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6949         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6950         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6951         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6952         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6953         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6954         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6955         { } /* end */
6956 };
6957
6958 /*
6959  * 8ch mode
6960  */
6961 static struct hda_verb alc883_4ST_ch8_init[] = {
6962         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6963         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6964         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6965         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6966         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6967         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6968         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6969         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6970         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6971         { } /* end */
6972 };
6973
6974 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6975         { 2, alc883_4ST_ch2_init },
6976         { 4, alc883_4ST_ch4_init },
6977         { 6, alc883_4ST_ch6_init },
6978         { 8, alc883_4ST_ch8_init },
6979 };
6980
6981
6982 /*
6983  * 2ch mode
6984  */
6985 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6986         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6987         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6988         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6989         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6990         { } /* end */
6991 };
6992
6993 /*
6994  * 4ch mode
6995  */
6996 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6997         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6998         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6999         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7000         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7001         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7002         { } /* end */
7003 };
7004
7005 /*
7006  * 6ch mode
7007  */
7008 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7009         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7010         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7011         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7012         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7013         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7014         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7015         { } /* end */
7016 };
7017
7018 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7019         { 2, alc883_3ST_ch2_intel_init },
7020         { 4, alc883_3ST_ch4_intel_init },
7021         { 6, alc883_3ST_ch6_intel_init },
7022 };
7023
7024 /*
7025  * 2ch mode
7026  */
7027 static struct hda_verb alc889_ch2_intel_init[] = {
7028         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7029         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7030         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7031         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7032         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7033         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7034         { } /* end */
7035 };
7036
7037 /*
7038  * 6ch mode
7039  */
7040 static struct hda_verb alc889_ch6_intel_init[] = {
7041         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7042         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7043         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7044         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7045         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7046         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7047         { } /* end */
7048 };
7049
7050 /*
7051  * 8ch mode
7052  */
7053 static struct hda_verb alc889_ch8_intel_init[] = {
7054         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7055         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7056         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7057         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7058         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7059         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7060         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7061         { } /* end */
7062 };
7063
7064 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7065         { 2, alc889_ch2_intel_init },
7066         { 6, alc889_ch6_intel_init },
7067         { 8, alc889_ch8_intel_init },
7068 };
7069
7070 /*
7071  * 6ch mode
7072  */
7073 static struct hda_verb alc883_sixstack_ch6_init[] = {
7074         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7075         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7076         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7077         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7078         { } /* end */
7079 };
7080
7081 /*
7082  * 8ch mode
7083  */
7084 static struct hda_verb alc883_sixstack_ch8_init[] = {
7085         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7086         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7087         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7088         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7089         { } /* end */
7090 };
7091
7092 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7093         { 6, alc883_sixstack_ch6_init },
7094         { 8, alc883_sixstack_ch8_init },
7095 };
7096
7097
7098 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7099  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7100  */
7101 static struct snd_kcontrol_new alc882_base_mixer[] = {
7102         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7103         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7104         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7105         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7106         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7107         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7108         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7109         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7110         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7111         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7112         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7113         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7114         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7115         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7116         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7117         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7118         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7119         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7120         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7121         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7122         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7123         { } /* end */
7124 };
7125
7126 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7127         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7128         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7129         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7130         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7131         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7132         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7133         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7134         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7135         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7136         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7137         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7138         { } /* end */
7139 };
7140
7141 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7142         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7143         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7144         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7145         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7146         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7147         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7148         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7149         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7150         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7151         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7152         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7153         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7154         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7155         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7156         { } /* end */
7157 };
7158
7159 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7160         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7161         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7162         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7163         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7164         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7165         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7166         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7167         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7168         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7169         { } /* end */
7170 };
7171
7172
7173 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7174         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7175         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7176         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7177         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7178         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7179         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7180         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7181         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7182         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7183         { } /* end */
7184 };
7185
7186 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7187         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7188         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7189         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7190         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7191         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7192         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7193         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7194         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7195         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7196         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7197         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7198         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7199         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7200         { } /* end */
7201 };
7202
7203 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7204  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7205  */
7206 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7207         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7208         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7209         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7210         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7211         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7212         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7213         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7214         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7215         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7216         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7217         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7218         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7219         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7220         { } /* end */
7221 };
7222
7223 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7224         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7225         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7226         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7227         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7228         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7229         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7230         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7231         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7232         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7233         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7234         { } /* end */
7235 };
7236
7237 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7238         {
7239                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7240                 .name = "Channel Mode",
7241                 .info = alc_ch_mode_info,
7242                 .get = alc_ch_mode_get,
7243                 .put = alc_ch_mode_put,
7244         },
7245         { } /* end */
7246 };
7247
7248 static struct hda_verb alc882_base_init_verbs[] = {
7249         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7250         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7251         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7252         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7253         /* Rear mixer */
7254         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7255         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7256         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7257         /* CLFE mixer */
7258         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7259         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7260         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7261         /* Side mixer */
7262         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7263         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7264         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7265
7266         /* mute analog input loopbacks */
7267         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7268         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7269         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7270         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7271         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7272
7273         /* Front Pin: output 0 (0x0c) */
7274         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7275         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7276         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7277         /* Rear Pin: output 1 (0x0d) */
7278         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7279         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7280         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7281         /* CLFE Pin: output 2 (0x0e) */
7282         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7283         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7284         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7285         /* Side Pin: output 3 (0x0f) */
7286         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7287         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7288         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7289         /* Mic (rear) pin: input vref at 80% */
7290         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7291         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7292         /* Front Mic pin: input vref at 80% */
7293         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7294         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7295         /* Line In pin: input */
7296         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7297         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7298         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7299         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7300         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7301         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7302         /* CD pin widget for input */
7303         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7304
7305         /* FIXME: use matrix-type input source selection */
7306         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7307         /* Input mixer2 */
7308         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7309         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7310         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7311         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7312         /* Input mixer3 */
7313         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7314         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7315         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7316         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7317         /* ADC2: mute amp left and right */
7318         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7319         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7320         /* ADC3: mute amp left and right */
7321         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7322         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7323
7324         { }
7325 };
7326
7327 static struct hda_verb alc882_adc1_init_verbs[] = {
7328         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7329         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7330         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7331         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7332         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7333         /* ADC1: mute amp left and right */
7334         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7335         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7336         { }
7337 };
7338
7339 static struct hda_verb alc882_eapd_verbs[] = {
7340         /* change to EAPD mode */
7341         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7342         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7343         { }
7344 };
7345
7346 static struct hda_verb alc889_eapd_verbs[] = {
7347         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7348         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7349         { }
7350 };
7351
7352 static struct hda_verb alc_hp15_unsol_verbs[] = {
7353         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7354         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7355         {}
7356 };
7357
7358 static struct hda_verb alc885_init_verbs[] = {
7359         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7360         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7361         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7362         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7363         /* Rear mixer */
7364         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7365         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7366         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7367         /* CLFE mixer */
7368         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7369         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7370         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7371         /* Side mixer */
7372         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7373         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7374         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7375
7376         /* mute analog input loopbacks */
7377         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7378         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7379         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7380
7381         /* Front HP Pin: output 0 (0x0c) */
7382         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7383         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7384         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7385         /* Front Pin: output 0 (0x0c) */
7386         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7387         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7388         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7389         /* Rear Pin: output 1 (0x0d) */
7390         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7391         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7392         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7393         /* CLFE Pin: output 2 (0x0e) */
7394         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7395         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7396         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7397         /* Side Pin: output 3 (0x0f) */
7398         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7399         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7400         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7401         /* Mic (rear) pin: input vref at 80% */
7402         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7403         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7404         /* Front Mic pin: input vref at 80% */
7405         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7406         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7407         /* Line In pin: input */
7408         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7409         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7410
7411         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7412         /* Input mixer1 */
7413         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7414         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7415         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7416         /* Input mixer2 */
7417         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7418         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7419         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7420         /* Input mixer3 */
7421         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7422         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7423         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7424         /* ADC2: mute amp left and right */
7425         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7426         /* ADC3: mute amp left and right */
7427         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7428
7429         { }
7430 };
7431
7432 static struct hda_verb alc885_init_input_verbs[] = {
7433         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7434         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7435         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7436         { }
7437 };
7438
7439
7440 /* Unmute Selector 24h and set the default input to front mic */
7441 static struct hda_verb alc889_init_input_verbs[] = {
7442         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7443         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7444         { }
7445 };
7446
7447
7448 #define alc883_init_verbs       alc882_base_init_verbs
7449
7450 /* Mac Pro test */
7451 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7452         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7453         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7454         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7455         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7456         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7457         /* FIXME: this looks suspicious...
7458         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7459         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7460         */
7461         { } /* end */
7462 };
7463
7464 static struct hda_verb alc882_macpro_init_verbs[] = {
7465         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7466         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7467         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7468         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7469         /* Front Pin: output 0 (0x0c) */
7470         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7471         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7472         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7473         /* Front Mic pin: input vref at 80% */
7474         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7475         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7476         /* Speaker:  output */
7477         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7478         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7479         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7480         /* Headphone output (output 0 - 0x0c) */
7481         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7482         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7483         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7484
7485         /* FIXME: use matrix-type input source selection */
7486         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7487         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7488         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7489         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7490         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7491         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7492         /* Input mixer2 */
7493         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7494         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7495         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7496         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7497         /* Input mixer3 */
7498         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7499         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7500         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7501         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7502         /* ADC1: mute amp left and right */
7503         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7504         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7505         /* ADC2: mute amp left and right */
7506         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7507         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7508         /* ADC3: mute amp left and right */
7509         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7510         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7511
7512         { }
7513 };
7514
7515 /* Macbook 5,1 */
7516 static struct hda_verb alc885_mb5_init_verbs[] = {
7517         /* DACs */
7518         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7519         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7520         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7521         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7522         /* Front mixer */
7523         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7524         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7525         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7526         /* Surround mixer */
7527         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7528         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7529         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7530         /* LFE mixer */
7531         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7532         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7533         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7534         /* HP mixer */
7535         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7536         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7537         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7538         /* Front Pin (0x0c) */
7539         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7540         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7541         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7542         /* LFE Pin (0x0e) */
7543         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7544         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7545         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7546         /* HP Pin (0x0f) */
7547         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7548         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7549         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7550         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7551         /* Front Mic pin: input vref at 80% */
7552         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7553         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7554         /* Line In pin */
7555         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7556         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7557
7558         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7559         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7560         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7561         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7562         { }
7563 };
7564
7565 /* Macbook Pro rev3 */
7566 static struct hda_verb alc885_mbp3_init_verbs[] = {
7567         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7568         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7569         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7570         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7571         /* Rear mixer */
7572         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7573         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7574         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7575         /* HP mixer */
7576         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7577         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7578         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7579         /* Front Pin: output 0 (0x0c) */
7580         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7581         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7582         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7583         /* HP Pin: output 0 (0x0e) */
7584         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7585         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7586         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7587         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7588         /* Mic (rear) pin: input vref at 80% */
7589         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7590         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7591         /* Front Mic pin: input vref at 80% */
7592         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7593         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7594         /* Line In pin: use output 1 when in LineOut mode */
7595         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7596         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7597         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7598
7599         /* FIXME: use matrix-type input source selection */
7600         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7601         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7602         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7603         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7604         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7605         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7606         /* Input mixer2 */
7607         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7608         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7609         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7610         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7611         /* Input mixer3 */
7612         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7613         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7614         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7615         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7616         /* ADC1: mute amp left and right */
7617         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7618         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7619         /* ADC2: mute amp left and right */
7620         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7621         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7622         /* ADC3: mute amp left and right */
7623         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7624         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7625
7626         { }
7627 };
7628
7629 /* iMac 9,1 */
7630 static struct hda_verb alc885_imac91_init_verbs[] = {
7631         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7632         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7633         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7634         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7635         /* Rear mixer */
7636         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7637         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7638         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7639         /* HP Pin: output 0 (0x0c) */
7640         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7641         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7642         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7643         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7644         /* Internal Speakers: output 0 (0x0d) */
7645         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7646         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7647         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7648         /* Mic (rear) pin: input vref at 80% */
7649         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7650         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7651         /* Front Mic pin: input vref at 80% */
7652         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7653         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7654         /* Line In pin: use output 1 when in LineOut mode */
7655         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7656         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7657         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7658
7659         /* FIXME: use matrix-type input source selection */
7660         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7661         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7662         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7663         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7664         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7665         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7666         /* Input mixer2 */
7667         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7668         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7669         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7670         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7671         /* Input mixer3 */
7672         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7673         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7674         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7675         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7676         /* ADC1: mute amp left and right */
7677         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7678         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7679         /* ADC2: mute amp left and right */
7680         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7681         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7682         /* ADC3: mute amp left and right */
7683         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7684         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7685
7686         { }
7687 };
7688
7689 /* iMac 24 mixer. */
7690 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7691         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7692         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7693         { } /* end */
7694 };
7695
7696 /* iMac 24 init verbs. */
7697 static struct hda_verb alc885_imac24_init_verbs[] = {
7698         /* Internal speakers: output 0 (0x0c) */
7699         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7700         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7701         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7702         /* Internal speakers: output 0 (0x0c) */
7703         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7704         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7705         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7706         /* Headphone: output 0 (0x0c) */
7707         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7708         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7709         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7710         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7711         /* Front Mic: input vref at 80% */
7712         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7713         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7714         { }
7715 };
7716
7717 /* Toggle speaker-output according to the hp-jack state */
7718 static void alc885_imac24_setup(struct hda_codec *codec)
7719 {
7720         struct alc_spec *spec = codec->spec;
7721
7722         spec->autocfg.hp_pins[0] = 0x14;
7723         spec->autocfg.speaker_pins[0] = 0x18;
7724         spec->autocfg.speaker_pins[1] = 0x1a;
7725 }
7726
7727 static void alc885_mbp3_setup(struct hda_codec *codec)
7728 {
7729         struct alc_spec *spec = codec->spec;
7730
7731         spec->autocfg.hp_pins[0] = 0x15;
7732         spec->autocfg.speaker_pins[0] = 0x14;
7733 }
7734
7735 static void alc885_mb5_automute(struct hda_codec *codec)
7736 {
7737         unsigned int present;
7738
7739         present = snd_hda_codec_read(codec, 0x14, 0,
7740                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7741         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
7742                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7743         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
7744                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7745
7746 }
7747
7748 static void alc885_mb5_unsol_event(struct hda_codec *codec,
7749                                     unsigned int res)
7750 {
7751         /* Headphone insertion or removal. */
7752         if ((res >> 26) == ALC880_HP_EVENT)
7753                 alc885_mb5_automute(codec);
7754 }
7755
7756 static void alc885_imac91_automute(struct hda_codec *codec)
7757 {
7758         unsigned int present;
7759
7760         present = snd_hda_codec_read(codec, 0x14, 0,
7761                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7762         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7763                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7764         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
7765                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7766
7767 }
7768
7769 static void alc885_imac91_unsol_event(struct hda_codec *codec,
7770                                     unsigned int res)
7771 {
7772         /* Headphone insertion or removal. */
7773         if ((res >> 26) == ALC880_HP_EVENT)
7774                 alc885_imac91_automute(codec);
7775 }
7776
7777 static struct hda_verb alc882_targa_verbs[] = {
7778         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7779         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7780
7781         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7782         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7783
7784         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7785         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7786         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7787
7788         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7789         { } /* end */
7790 };
7791
7792 /* toggle speaker-output according to the hp-jack state */
7793 static void alc882_targa_automute(struct hda_codec *codec)
7794 {
7795         struct alc_spec *spec = codec->spec;
7796         alc_automute_amp(codec);
7797         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7798                                   spec->jack_present ? 1 : 3);
7799 }
7800
7801 static void alc882_targa_setup(struct hda_codec *codec)
7802 {
7803         struct alc_spec *spec = codec->spec;
7804
7805         spec->autocfg.hp_pins[0] = 0x14;
7806         spec->autocfg.speaker_pins[0] = 0x1b;
7807 }
7808
7809 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7810 {
7811         if ((res >> 26) == ALC880_HP_EVENT)
7812                 alc882_targa_automute(codec);
7813 }
7814
7815 static struct hda_verb alc882_asus_a7j_verbs[] = {
7816         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7817         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7818
7819         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7820         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7821         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7822
7823         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7824         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7825         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7826
7827         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7828         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7829         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7830         { } /* end */
7831 };
7832
7833 static struct hda_verb alc882_asus_a7m_verbs[] = {
7834         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7835         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7836
7837         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7838         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7839         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7840
7841         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7842         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7843         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7844
7845         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7846         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7847         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7848         { } /* end */
7849 };
7850
7851 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7852 {
7853         unsigned int gpiostate, gpiomask, gpiodir;
7854
7855         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7856                                        AC_VERB_GET_GPIO_DATA, 0);
7857
7858         if (!muted)
7859                 gpiostate |= (1 << pin);
7860         else
7861                 gpiostate &= ~(1 << pin);
7862
7863         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7864                                       AC_VERB_GET_GPIO_MASK, 0);
7865         gpiomask |= (1 << pin);
7866
7867         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7868                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7869         gpiodir |= (1 << pin);
7870
7871
7872         snd_hda_codec_write(codec, codec->afg, 0,
7873                             AC_VERB_SET_GPIO_MASK, gpiomask);
7874         snd_hda_codec_write(codec, codec->afg, 0,
7875                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7876
7877         msleep(1);
7878
7879         snd_hda_codec_write(codec, codec->afg, 0,
7880                             AC_VERB_SET_GPIO_DATA, gpiostate);
7881 }
7882
7883 /* set up GPIO at initialization */
7884 static void alc885_macpro_init_hook(struct hda_codec *codec)
7885 {
7886         alc882_gpio_mute(codec, 0, 0);
7887         alc882_gpio_mute(codec, 1, 0);
7888 }
7889
7890 /* set up GPIO and update auto-muting at initialization */
7891 static void alc885_imac24_init_hook(struct hda_codec *codec)
7892 {
7893         alc885_macpro_init_hook(codec);
7894         alc_automute_amp(codec);
7895 }
7896
7897 /*
7898  * generic initialization of ADC, input mixers and output mixers
7899  */
7900 static struct hda_verb alc883_auto_init_verbs[] = {
7901         /*
7902          * Unmute ADC0-2 and set the default input to mic-in
7903          */
7904         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7905         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7906         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7907         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7908
7909         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7910          * mixer widget
7911          * Note: PASD motherboards uses the Line In 2 as the input for
7912          * front panel mic (mic 2)
7913          */
7914         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7915         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7916         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7917         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7918         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7919         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7920
7921         /*
7922          * Set up output mixers (0x0c - 0x0f)
7923          */
7924         /* set vol=0 to output mixers */
7925         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7926         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7927         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7928         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7929         /* set up input amps for analog loopback */
7930         /* Amp Indices: DAC = 0, mixer = 1 */
7931         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7932         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7933         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7934         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7935         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7936         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7937         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7938         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7939         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7940         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7941
7942         /* FIXME: use matrix-type input source selection */
7943         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7944         /* Input mixer2 */
7945         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7946         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7947         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7948         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7949         /* Input mixer3 */
7950         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7951         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7952         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7953         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7954
7955         { }
7956 };
7957
7958 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7959 static struct hda_verb alc889A_mb31_ch2_init[] = {
7960         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7961         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7962         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7963         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7964         { } /* end */
7965 };
7966
7967 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7968 static struct hda_verb alc889A_mb31_ch4_init[] = {
7969         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7970         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7971         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7972         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7973         { } /* end */
7974 };
7975
7976 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7977 static struct hda_verb alc889A_mb31_ch5_init[] = {
7978         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7979         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7980         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7981         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7982         { } /* end */
7983 };
7984
7985 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7986 static struct hda_verb alc889A_mb31_ch6_init[] = {
7987         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7988         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7989         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7990         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7991         { } /* end */
7992 };
7993
7994 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7995         { 2, alc889A_mb31_ch2_init },
7996         { 4, alc889A_mb31_ch4_init },
7997         { 5, alc889A_mb31_ch5_init },
7998         { 6, alc889A_mb31_ch6_init },
7999 };
8000
8001 static struct hda_verb alc883_medion_eapd_verbs[] = {
8002         /* eanable EAPD on medion laptop */
8003         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8004         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8005         { }
8006 };
8007
8008 #define alc883_base_mixer       alc882_base_mixer
8009
8010 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8011         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8012         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8013         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8014         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8015         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8016         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8017         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8018         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8019         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8020         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8021         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8022         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8023         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8024         { } /* end */
8025 };
8026
8027 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8028         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8029         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8030         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8031         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8032         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8033         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8034         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8035         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8036         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8037         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8038         { } /* end */
8039 };
8040
8041 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8042         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8043         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8044         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8045         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8046         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8047         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8048         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8049         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8050         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8051         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8052         { } /* end */
8053 };
8054
8055 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8056         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8057         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8058         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8059         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8060         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8061         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8062         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8063         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8064         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8065         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8066         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8067         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8068         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8069         { } /* end */
8070 };
8071
8072 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8073         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8074         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8075         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8076         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8077         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8078         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8079         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8080         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8081         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8082         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8083         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8084         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8085         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8086         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8087         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8088         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8089         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8090         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8091         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8092         { } /* end */
8093 };
8094
8095 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8096         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8097         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8098         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8099         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8100         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8101                               HDA_OUTPUT),
8102         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8103         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8104         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8105         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8106         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8107         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8108         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8109         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8110         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8111         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8112         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8113         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8114         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8115         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8116         { } /* end */
8117 };
8118
8119 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8120         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8121         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8122         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8123         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8124         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8125                               HDA_OUTPUT),
8126         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8127         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8128         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8129         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8130         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8131         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8132         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8133         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8134         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8135         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8136         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8137         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8138         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8139         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8140         { } /* end */
8141 };
8142
8143 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8144         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8145         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8146         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8147         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8148         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8149         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8150         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8151         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8152         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8153         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8154         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8155         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8156         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8157         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8158         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8159         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8160         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8161         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8162         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8163         { } /* end */
8164 };
8165
8166 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8167         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8168         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8169         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8170         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8171         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8172         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8173         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8174         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8175         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8176         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8177         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8178         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8179         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8180         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8181         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8182         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8183         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8184         { } /* end */
8185 };
8186
8187 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8188         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8189         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8190         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8191         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8192         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8193         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8194         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8195         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8196         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8197         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8198         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8199         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8200         { } /* end */
8201 };
8202
8203 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8204         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8205         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8206         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8207         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8208         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8209         { } /* end */
8210 };
8211
8212 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8213         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8214         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8215         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8216         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8217         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8218         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8219         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8220         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8221         { } /* end */
8222 };
8223
8224 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8225         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8226         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8227         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8228         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8229         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8230         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8231         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8232         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8233         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8234         { } /* end */
8235 };
8236
8237 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8238         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8239         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8240         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8241         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8242         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8243         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8244         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8245         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8246         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8247         { } /* end */
8248 };
8249
8250 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8251         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8252         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8253         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8254         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8255         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8256         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8257         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8258         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8259         { } /* end */
8260 };
8261
8262 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8263         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8264         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8265         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8266         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
8267         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8268         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8269         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8270         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8272         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8273         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8274         { } /* end */
8275 };
8276
8277 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8278         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8279         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8280         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8281         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8282         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8283                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8284         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8285         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8286         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8287         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8288         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8289         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8290         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8291         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8292         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8293         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8294         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8295         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8296         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8297         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8298         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8299         { } /* end */
8300 };
8301
8302 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8303         /* Output mixers */
8304         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8305         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8306         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8307         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8308         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8309                 HDA_OUTPUT),
8310         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8311         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8312         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8313         /* Output switches */
8314         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8315         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8316         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8317         /* Boost mixers */
8318         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8319         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8320         /* Input mixers */
8321         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8322         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8323         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8324         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8325         { } /* end */
8326 };
8327
8328 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8329         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8330         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8331         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8332         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8333         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8334         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8335         { } /* end */
8336 };
8337
8338 static struct hda_bind_ctls alc883_bind_cap_vol = {
8339         .ops = &snd_hda_bind_vol,
8340         .values = {
8341                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8342                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8343                 0
8344         },
8345 };
8346
8347 static struct hda_bind_ctls alc883_bind_cap_switch = {
8348         .ops = &snd_hda_bind_sw,
8349         .values = {
8350                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8351                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8352                 0
8353         },
8354 };
8355
8356 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8357         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8358         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8359         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8360         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8361         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8362         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8363         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8364         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8365         { } /* end */
8366 };
8367
8368 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8369         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8370         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8371         {
8372                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8373                 /* .name = "Capture Source", */
8374                 .name = "Input Source",
8375                 .count = 1,
8376                 .info = alc_mux_enum_info,
8377                 .get = alc_mux_enum_get,
8378                 .put = alc_mux_enum_put,
8379         },
8380         { } /* end */
8381 };
8382
8383 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8384         {
8385                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8386                 .name = "Channel Mode",
8387                 .info = alc_ch_mode_info,
8388                 .get = alc_ch_mode_get,
8389                 .put = alc_ch_mode_put,
8390         },
8391         { } /* end */
8392 };
8393
8394 /* toggle speaker-output according to the hp-jack state */
8395 static void alc883_mitac_setup(struct hda_codec *codec)
8396 {
8397         struct alc_spec *spec = codec->spec;
8398
8399         spec->autocfg.hp_pins[0] = 0x15;
8400         spec->autocfg.speaker_pins[0] = 0x14;
8401         spec->autocfg.speaker_pins[1] = 0x17;
8402 }
8403
8404 /* auto-toggle front mic */
8405 /*
8406 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8407 {
8408         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8409
8410         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8411 }
8412 */
8413
8414 static struct hda_verb alc883_mitac_verbs[] = {
8415         /* HP */
8416         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8417         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8418         /* Subwoofer */
8419         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8420         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8421
8422         /* enable unsolicited event */
8423         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8424         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8425
8426         { } /* end */
8427 };
8428
8429 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8430         /* HP */
8431         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8432         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8433         /* Int speaker */
8434         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8435
8436         /* enable unsolicited event */
8437         /*
8438         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8439         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8440         */
8441
8442         { } /* end */
8443 };
8444
8445 static struct hda_verb alc883_clevo_m720_verbs[] = {
8446         /* HP */
8447         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8448         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8449         /* Int speaker */
8450         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8451         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8452
8453         /* enable unsolicited event */
8454         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8455         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8456
8457         { } /* end */
8458 };
8459
8460 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8461         /* HP */
8462         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8463         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8464         /* Subwoofer */
8465         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8466         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8467
8468         /* enable unsolicited event */
8469         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8470
8471         { } /* end */
8472 };
8473
8474 static struct hda_verb alc883_targa_verbs[] = {
8475         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8476         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8477
8478         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8479         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8480
8481 /* Connect Line-Out side jack (SPDIF) to Side */
8482         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8483         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8484         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8485 /* Connect Mic jack to CLFE */
8486         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8487         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8488         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8489 /* Connect Line-in jack to Surround */
8490         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8491         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8492         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8493 /* Connect HP out jack to Front */
8494         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8495         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8496         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8497
8498         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8499
8500         { } /* end */
8501 };
8502
8503 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8504         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8505         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8506         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8507         { } /* end */
8508 };
8509
8510 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8511         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8512         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8513         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8514         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8515         { } /* end */
8516 };
8517
8518 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8519         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8520         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8521         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8522         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8523         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8524         { } /* end */
8525 };
8526
8527 static struct hda_verb alc883_haier_w66_verbs[] = {
8528         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8529         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8530
8531         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8532
8533         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8534         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8535         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8536         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8537         { } /* end */
8538 };
8539
8540 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8541         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8542         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8543         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8544         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8545         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8546         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8547         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8548         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8549         { } /* end */
8550 };
8551
8552 static struct hda_verb alc888_6st_dell_verbs[] = {
8553         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8554         { }
8555 };
8556
8557 static struct hda_verb alc883_vaiott_verbs[] = {
8558         /* HP */
8559         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8560         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8561
8562         /* enable unsolicited event */
8563         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8564
8565         { } /* end */
8566 };
8567
8568 static void alc888_3st_hp_setup(struct hda_codec *codec)
8569 {
8570         struct alc_spec *spec = codec->spec;
8571
8572         spec->autocfg.hp_pins[0] = 0x1b;
8573         spec->autocfg.speaker_pins[0] = 0x14;
8574         spec->autocfg.speaker_pins[1] = 0x16;
8575         spec->autocfg.speaker_pins[2] = 0x18;
8576 }
8577
8578 static struct hda_verb alc888_3st_hp_verbs[] = {
8579         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8580         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8581         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8582         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8583         { } /* end */
8584 };
8585
8586 /*
8587  * 2ch mode
8588  */
8589 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8590         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8591         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8592         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8593         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8594         { } /* end */
8595 };
8596
8597 /*
8598  * 4ch mode
8599  */
8600 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8601         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8602         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8603         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8604         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8605         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8606         { } /* end */
8607 };
8608
8609 /*
8610  * 6ch mode
8611  */
8612 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8613         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8614         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8615         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8616         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8617         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8618         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8619         { } /* end */
8620 };
8621
8622 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8623         { 2, alc888_3st_hp_2ch_init },
8624         { 4, alc888_3st_hp_4ch_init },
8625         { 6, alc888_3st_hp_6ch_init },
8626 };
8627
8628 /* toggle front-jack and RCA according to the hp-jack state */
8629 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8630 {
8631         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8632
8633         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8634                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8635         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8636                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8637 }
8638
8639 /* toggle RCA according to the front-jack state */
8640 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8641 {
8642         unsigned int present = snd_hda_jack_detect(codec, 0x14);
8643
8644         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8645                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8646 }
8647
8648 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8649                                              unsigned int res)
8650 {
8651         if ((res >> 26) == ALC880_HP_EVENT)
8652                 alc888_lenovo_ms7195_front_automute(codec);
8653         if ((res >> 26) == ALC880_FRONT_EVENT)
8654                 alc888_lenovo_ms7195_rca_automute(codec);
8655 }
8656
8657 static struct hda_verb alc883_medion_md2_verbs[] = {
8658         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8659         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8660
8661         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8662
8663         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8664         { } /* end */
8665 };
8666
8667 /* toggle speaker-output according to the hp-jack state */
8668 static void alc883_medion_md2_setup(struct hda_codec *codec)
8669 {
8670         struct alc_spec *spec = codec->spec;
8671
8672         spec->autocfg.hp_pins[0] = 0x14;
8673         spec->autocfg.speaker_pins[0] = 0x15;
8674 }
8675
8676 /* toggle speaker-output according to the hp-jack state */
8677 #define alc883_targa_init_hook          alc882_targa_init_hook
8678 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8679
8680 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8681 {
8682         unsigned int present;
8683
8684         present = snd_hda_jack_detect(codec, 0x18);
8685         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8686                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8687 }
8688
8689 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8690 {
8691         struct alc_spec *spec = codec->spec;
8692
8693         spec->autocfg.hp_pins[0] = 0x15;
8694         spec->autocfg.speaker_pins[0] = 0x14;
8695 }
8696
8697 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8698 {
8699         alc_automute_amp(codec);
8700         alc883_clevo_m720_mic_automute(codec);
8701 }
8702
8703 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8704                                            unsigned int res)
8705 {
8706         switch (res >> 26) {
8707         case ALC880_MIC_EVENT:
8708                 alc883_clevo_m720_mic_automute(codec);
8709                 break;
8710         default:
8711                 alc_automute_amp_unsol_event(codec, res);
8712                 break;
8713         }
8714 }
8715
8716 /* toggle speaker-output according to the hp-jack state */
8717 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8718 {
8719         struct alc_spec *spec = codec->spec;
8720
8721         spec->autocfg.hp_pins[0] = 0x14;
8722         spec->autocfg.speaker_pins[0] = 0x15;
8723 }
8724
8725 static void alc883_haier_w66_setup(struct hda_codec *codec)
8726 {
8727         struct alc_spec *spec = codec->spec;
8728
8729         spec->autocfg.hp_pins[0] = 0x1b;
8730         spec->autocfg.speaker_pins[0] = 0x14;
8731 }
8732
8733 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8734 {
8735         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8736
8737         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8738                                  HDA_AMP_MUTE, bits);
8739 }
8740
8741 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8742 {
8743         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8744
8745         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8746                                  HDA_AMP_MUTE, bits);
8747         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8748                                  HDA_AMP_MUTE, bits);
8749 }
8750
8751 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8752                                            unsigned int res)
8753 {
8754         if ((res >> 26) == ALC880_HP_EVENT)
8755                 alc883_lenovo_101e_all_automute(codec);
8756         if ((res >> 26) == ALC880_FRONT_EVENT)
8757                 alc883_lenovo_101e_ispeaker_automute(codec);
8758 }
8759
8760 /* toggle speaker-output according to the hp-jack state */
8761 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8762 {
8763         struct alc_spec *spec = codec->spec;
8764
8765         spec->autocfg.hp_pins[0] = 0x14;
8766         spec->autocfg.speaker_pins[0] = 0x15;
8767         spec->autocfg.speaker_pins[1] = 0x16;
8768 }
8769
8770 static struct hda_verb alc883_acer_eapd_verbs[] = {
8771         /* HP Pin: output 0 (0x0c) */
8772         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8773         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8774         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8775         /* Front Pin: output 0 (0x0c) */
8776         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8777         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8778         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8779         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8780         /* eanable EAPD on medion laptop */
8781         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8782         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8783         /* enable unsolicited event */
8784         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8785         { }
8786 };
8787
8788 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8789         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8790         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8791         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8792         { } /* end */
8793 };
8794
8795 static void alc888_6st_dell_setup(struct hda_codec *codec)
8796 {
8797         struct alc_spec *spec = codec->spec;
8798
8799         spec->autocfg.hp_pins[0] = 0x1b;
8800         spec->autocfg.speaker_pins[0] = 0x14;
8801         spec->autocfg.speaker_pins[1] = 0x15;
8802         spec->autocfg.speaker_pins[2] = 0x16;
8803         spec->autocfg.speaker_pins[3] = 0x17;
8804 }
8805
8806 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
8807 {
8808         struct alc_spec *spec = codec->spec;
8809
8810         spec->autocfg.hp_pins[0] = 0x1b;
8811         spec->autocfg.speaker_pins[0] = 0x14;
8812         spec->autocfg.speaker_pins[1] = 0x15;
8813         spec->autocfg.speaker_pins[2] = 0x16;
8814         spec->autocfg.speaker_pins[3] = 0x17;
8815         spec->autocfg.speaker_pins[4] = 0x1a;
8816 }
8817
8818 static void alc883_vaiott_setup(struct hda_codec *codec)
8819 {
8820         struct alc_spec *spec = codec->spec;
8821
8822         spec->autocfg.hp_pins[0] = 0x15;
8823         spec->autocfg.speaker_pins[0] = 0x14;
8824         spec->autocfg.speaker_pins[1] = 0x17;
8825 }
8826
8827 static struct hda_verb alc888_asus_m90v_verbs[] = {
8828         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8829         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8830         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8831         /* enable unsolicited event */
8832         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8833         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8834         { } /* end */
8835 };
8836
8837 static void alc883_mode2_setup(struct hda_codec *codec)
8838 {
8839         struct alc_spec *spec = codec->spec;
8840
8841         spec->autocfg.hp_pins[0] = 0x1b;
8842         spec->autocfg.speaker_pins[0] = 0x14;
8843         spec->autocfg.speaker_pins[1] = 0x15;
8844         spec->autocfg.speaker_pins[2] = 0x16;
8845         spec->ext_mic.pin = 0x18;
8846         spec->int_mic.pin = 0x19;
8847         spec->ext_mic.mux_idx = 0;
8848         spec->int_mic.mux_idx = 1;
8849         spec->auto_mic = 1;
8850 }
8851
8852 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8853         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8854         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8855         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8856         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8857         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8858         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8859         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8860         /* enable unsolicited event */
8861         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8862         { } /* end */
8863 };
8864
8865 static void alc883_eee1601_inithook(struct hda_codec *codec)
8866 {
8867         struct alc_spec *spec = codec->spec;
8868
8869         spec->autocfg.hp_pins[0] = 0x14;
8870         spec->autocfg.speaker_pins[0] = 0x1b;
8871         alc_automute_pin(codec);
8872 }
8873
8874 static struct hda_verb alc889A_mb31_verbs[] = {
8875         /* Init rear pin (used as headphone output) */
8876         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8877         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8878         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8879         /* Init line pin (used as output in 4ch and 6ch mode) */
8880         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8881         /* Init line 2 pin (used as headphone out by default) */
8882         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8883         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8884         { } /* end */
8885 };
8886
8887 /* Mute speakers according to the headphone jack state */
8888 static void alc889A_mb31_automute(struct hda_codec *codec)
8889 {
8890         unsigned int present;
8891
8892         /* Mute only in 2ch or 4ch mode */
8893         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8894             == 0x00) {
8895                 present = snd_hda_jack_detect(codec, 0x15);
8896                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8897                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8898                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8899                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8900         }
8901 }
8902
8903 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8904 {
8905         if ((res >> 26) == ALC880_HP_EVENT)
8906                 alc889A_mb31_automute(codec);
8907 }
8908
8909
8910 #ifdef CONFIG_SND_HDA_POWER_SAVE
8911 #define alc882_loopbacks        alc880_loopbacks
8912 #endif
8913
8914 /* pcm configuration: identical with ALC880 */
8915 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8916 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8917 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8918 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8919
8920 static hda_nid_t alc883_slave_dig_outs[] = {
8921         ALC1200_DIGOUT_NID, 0,
8922 };
8923
8924 static hda_nid_t alc1200_slave_dig_outs[] = {
8925         ALC883_DIGOUT_NID, 0,
8926 };
8927
8928 /*
8929  * configuration and preset
8930  */
8931 static const char *alc882_models[ALC882_MODEL_LAST] = {
8932         [ALC882_3ST_DIG]        = "3stack-dig",
8933         [ALC882_6ST_DIG]        = "6stack-dig",
8934         [ALC882_ARIMA]          = "arima",
8935         [ALC882_W2JC]           = "w2jc",
8936         [ALC882_TARGA]          = "targa",
8937         [ALC882_ASUS_A7J]       = "asus-a7j",
8938         [ALC882_ASUS_A7M]       = "asus-a7m",
8939         [ALC885_MACPRO]         = "macpro",
8940         [ALC885_MB5]            = "mb5",
8941         [ALC885_MBP3]           = "mbp3",
8942         [ALC885_IMAC24]         = "imac24",
8943         [ALC885_IMAC91]         = "imac91",
8944         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8945         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8946         [ALC883_3ST_6ch]        = "3stack-6ch",
8947         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8948         [ALC883_TARGA_DIG]      = "targa-dig",
8949         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8950         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8951         [ALC883_ACER]           = "acer",
8952         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8953         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8954         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8955         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8956         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
8957         [ALC883_MEDION]         = "medion",
8958         [ALC883_MEDION_MD2]     = "medion-md2",
8959         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8960         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8961         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8962         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8963         [ALC888_LENOVO_SKY] = "lenovo-sky",
8964         [ALC883_HAIER_W66]      = "haier-w66",
8965         [ALC888_3ST_HP]         = "3stack-hp",
8966         [ALC888_6ST_DELL]       = "6stack-dell",
8967         [ALC883_MITAC]          = "mitac",
8968         [ALC883_CLEVO_M540R]    = "clevo-m540r",
8969         [ALC883_CLEVO_M720]     = "clevo-m720",
8970         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8971         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8972         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8973         [ALC889A_INTEL]         = "intel-alc889a",
8974         [ALC889_INTEL]          = "intel-x58",
8975         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8976         [ALC889A_MB31]          = "mb31",
8977         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8978         [ALC882_AUTO]           = "auto",
8979 };
8980
8981 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8982         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8983
8984         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8985         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8986         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8987         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8988         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8989         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8990         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8991                 ALC888_ACER_ASPIRE_4930G),
8992         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8993                 ALC888_ACER_ASPIRE_4930G),
8994         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8995                 ALC888_ACER_ASPIRE_8930G),
8996         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8997                 ALC888_ACER_ASPIRE_8930G),
8998         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8999         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9000         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9001                 ALC888_ACER_ASPIRE_6530G),
9002         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9003                 ALC888_ACER_ASPIRE_6530G),
9004         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9005                 ALC888_ACER_ASPIRE_7730G),
9006         /* default Acer -- disabled as it causes more problems.
9007          *    model=auto should work fine now
9008          */
9009         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9010
9011         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9012
9013         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9014         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9015         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9016         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9017         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9018         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9019
9020         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9021         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9022         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9023         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9024         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9025         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9026         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9027         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9028         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9029         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9030         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9031
9032         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9033         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9034         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9035         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9036         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9037         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9038         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9039         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9040         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9041
9042         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9043         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9044         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9045         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9046         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9047         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9048         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9049         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9050         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9051         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9052         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9053         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9054         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9055         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9056         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9057         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9058         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9059         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9060         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9061         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9062         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9063         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9064         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9065         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9066         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9067         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9068         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9069         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9070         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9071
9072         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9073         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9074         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9075         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9076         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9077         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9078         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9079         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9080         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9081                       ALC883_FUJITSU_PI2515),
9082         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9083                 ALC888_FUJITSU_XA3530),
9084         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9085         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9086         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9087         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9088         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9089         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9090         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9091         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9092         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9093
9094         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9095         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9096         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9097         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9098         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9099         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9100         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
9101
9102         {}
9103 };
9104
9105 /* codec SSID table for Intel Mac */
9106 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9107         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9108         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9109         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9110         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9111         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9112         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9113         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9114         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9115         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9116         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9117         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9118         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9119         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9120          * so apparently no perfect solution yet
9121          */
9122         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9123         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9124         {} /* terminator */
9125 };
9126
9127 static struct alc_config_preset alc882_presets[] = {
9128         [ALC882_3ST_DIG] = {
9129                 .mixers = { alc882_base_mixer },
9130                 .init_verbs = { alc882_base_init_verbs,
9131                                 alc882_adc1_init_verbs },
9132                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9133                 .dac_nids = alc882_dac_nids,
9134                 .dig_out_nid = ALC882_DIGOUT_NID,
9135                 .dig_in_nid = ALC882_DIGIN_NID,
9136                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9137                 .channel_mode = alc882_ch_modes,
9138                 .need_dac_fix = 1,
9139                 .input_mux = &alc882_capture_source,
9140         },
9141         [ALC882_6ST_DIG] = {
9142                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9143                 .init_verbs = { alc882_base_init_verbs,
9144                                 alc882_adc1_init_verbs },
9145                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9146                 .dac_nids = alc882_dac_nids,
9147                 .dig_out_nid = ALC882_DIGOUT_NID,
9148                 .dig_in_nid = ALC882_DIGIN_NID,
9149                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9150                 .channel_mode = alc882_sixstack_modes,
9151                 .input_mux = &alc882_capture_source,
9152         },
9153         [ALC882_ARIMA] = {
9154                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9155                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9156                                 alc882_eapd_verbs },
9157                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9158                 .dac_nids = alc882_dac_nids,
9159                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9160                 .channel_mode = alc882_sixstack_modes,
9161                 .input_mux = &alc882_capture_source,
9162         },
9163         [ALC882_W2JC] = {
9164                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9165                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9166                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9167                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9168                 .dac_nids = alc882_dac_nids,
9169                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9170                 .channel_mode = alc880_threestack_modes,
9171                 .need_dac_fix = 1,
9172                 .input_mux = &alc882_capture_source,
9173                 .dig_out_nid = ALC882_DIGOUT_NID,
9174         },
9175         [ALC885_MBP3] = {
9176                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9177                 .init_verbs = { alc885_mbp3_init_verbs,
9178                                 alc880_gpio1_init_verbs },
9179                 .num_dacs = 2,
9180                 .dac_nids = alc882_dac_nids,
9181                 .hp_nid = 0x04,
9182                 .channel_mode = alc885_mbp_4ch_modes,
9183                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9184                 .input_mux = &alc882_capture_source,
9185                 .dig_out_nid = ALC882_DIGOUT_NID,
9186                 .dig_in_nid = ALC882_DIGIN_NID,
9187                 .unsol_event = alc_automute_amp_unsol_event,
9188                 .setup = alc885_mbp3_setup,
9189                 .init_hook = alc_automute_amp,
9190         },
9191         [ALC885_MB5] = {
9192                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9193                 .init_verbs = { alc885_mb5_init_verbs,
9194                                 alc880_gpio1_init_verbs },
9195                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9196                 .dac_nids = alc882_dac_nids,
9197                 .channel_mode = alc885_mb5_6ch_modes,
9198                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9199                 .input_mux = &mb5_capture_source,
9200                 .dig_out_nid = ALC882_DIGOUT_NID,
9201                 .dig_in_nid = ALC882_DIGIN_NID,
9202                 .unsol_event = alc885_mb5_unsol_event,
9203                 .init_hook = alc885_mb5_automute,
9204         },
9205         [ALC885_MACPRO] = {
9206                 .mixers = { alc882_macpro_mixer },
9207                 .init_verbs = { alc882_macpro_init_verbs },
9208                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9209                 .dac_nids = alc882_dac_nids,
9210                 .dig_out_nid = ALC882_DIGOUT_NID,
9211                 .dig_in_nid = ALC882_DIGIN_NID,
9212                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9213                 .channel_mode = alc882_ch_modes,
9214                 .input_mux = &alc882_capture_source,
9215                 .init_hook = alc885_macpro_init_hook,
9216         },
9217         [ALC885_IMAC24] = {
9218                 .mixers = { alc885_imac24_mixer },
9219                 .init_verbs = { alc885_imac24_init_verbs },
9220                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9221                 .dac_nids = alc882_dac_nids,
9222                 .dig_out_nid = ALC882_DIGOUT_NID,
9223                 .dig_in_nid = ALC882_DIGIN_NID,
9224                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9225                 .channel_mode = alc882_ch_modes,
9226                 .input_mux = &alc882_capture_source,
9227                 .unsol_event = alc_automute_amp_unsol_event,
9228                 .setup = alc885_imac24_setup,
9229                 .init_hook = alc885_imac24_init_hook,
9230         },
9231         [ALC885_IMAC91] = {
9232                 .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9233                 .init_verbs = { alc885_imac91_init_verbs,
9234                                 alc880_gpio1_init_verbs },
9235                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9236                 .dac_nids = alc882_dac_nids,
9237                 .channel_mode = alc885_mbp_4ch_modes,
9238                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9239                 .input_mux = &alc882_capture_source,
9240                 .dig_out_nid = ALC882_DIGOUT_NID,
9241                 .dig_in_nid = ALC882_DIGIN_NID,
9242                 .unsol_event = alc885_imac91_unsol_event,
9243                 .init_hook = alc885_imac91_automute,
9244         },
9245         [ALC882_TARGA] = {
9246                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9247                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9248                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9249                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9250                 .dac_nids = alc882_dac_nids,
9251                 .dig_out_nid = ALC882_DIGOUT_NID,
9252                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9253                 .adc_nids = alc882_adc_nids,
9254                 .capsrc_nids = alc882_capsrc_nids,
9255                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9256                 .channel_mode = alc882_3ST_6ch_modes,
9257                 .need_dac_fix = 1,
9258                 .input_mux = &alc882_capture_source,
9259                 .unsol_event = alc882_targa_unsol_event,
9260                 .setup = alc882_targa_setup,
9261                 .init_hook = alc882_targa_automute,
9262         },
9263         [ALC882_ASUS_A7J] = {
9264                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9265                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9266                                 alc882_asus_a7j_verbs},
9267                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9268                 .dac_nids = alc882_dac_nids,
9269                 .dig_out_nid = ALC882_DIGOUT_NID,
9270                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9271                 .adc_nids = alc882_adc_nids,
9272                 .capsrc_nids = alc882_capsrc_nids,
9273                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9274                 .channel_mode = alc882_3ST_6ch_modes,
9275                 .need_dac_fix = 1,
9276                 .input_mux = &alc882_capture_source,
9277         },
9278         [ALC882_ASUS_A7M] = {
9279                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9280                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9281                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9282                                 alc882_asus_a7m_verbs },
9283                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9284                 .dac_nids = alc882_dac_nids,
9285                 .dig_out_nid = ALC882_DIGOUT_NID,
9286                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9287                 .channel_mode = alc880_threestack_modes,
9288                 .need_dac_fix = 1,
9289                 .input_mux = &alc882_capture_source,
9290         },
9291         [ALC883_3ST_2ch_DIG] = {
9292                 .mixers = { alc883_3ST_2ch_mixer },
9293                 .init_verbs = { alc883_init_verbs },
9294                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9295                 .dac_nids = alc883_dac_nids,
9296                 .dig_out_nid = ALC883_DIGOUT_NID,
9297                 .dig_in_nid = ALC883_DIGIN_NID,
9298                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9299                 .channel_mode = alc883_3ST_2ch_modes,
9300                 .input_mux = &alc883_capture_source,
9301         },
9302         [ALC883_3ST_6ch_DIG] = {
9303                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9304                 .init_verbs = { alc883_init_verbs },
9305                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9306                 .dac_nids = alc883_dac_nids,
9307                 .dig_out_nid = ALC883_DIGOUT_NID,
9308                 .dig_in_nid = ALC883_DIGIN_NID,
9309                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9310                 .channel_mode = alc883_3ST_6ch_modes,
9311                 .need_dac_fix = 1,
9312                 .input_mux = &alc883_capture_source,
9313         },
9314         [ALC883_3ST_6ch] = {
9315                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9316                 .init_verbs = { alc883_init_verbs },
9317                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9318                 .dac_nids = alc883_dac_nids,
9319                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9320                 .channel_mode = alc883_3ST_6ch_modes,
9321                 .need_dac_fix = 1,
9322                 .input_mux = &alc883_capture_source,
9323         },
9324         [ALC883_3ST_6ch_INTEL] = {
9325                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9326                 .init_verbs = { alc883_init_verbs },
9327                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9328                 .dac_nids = alc883_dac_nids,
9329                 .dig_out_nid = ALC883_DIGOUT_NID,
9330                 .dig_in_nid = ALC883_DIGIN_NID,
9331                 .slave_dig_outs = alc883_slave_dig_outs,
9332                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9333                 .channel_mode = alc883_3ST_6ch_intel_modes,
9334                 .need_dac_fix = 1,
9335                 .input_mux = &alc883_3stack_6ch_intel,
9336         },
9337         [ALC889A_INTEL] = {
9338                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9339                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9340                                 alc_hp15_unsol_verbs },
9341                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9342                 .dac_nids = alc883_dac_nids,
9343                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9344                 .adc_nids = alc889_adc_nids,
9345                 .dig_out_nid = ALC883_DIGOUT_NID,
9346                 .dig_in_nid = ALC883_DIGIN_NID,
9347                 .slave_dig_outs = alc883_slave_dig_outs,
9348                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9349                 .channel_mode = alc889_8ch_intel_modes,
9350                 .capsrc_nids = alc889_capsrc_nids,
9351                 .input_mux = &alc889_capture_source,
9352                 .setup = alc889_automute_setup,
9353                 .init_hook = alc_automute_amp,
9354                 .unsol_event = alc_automute_amp_unsol_event,
9355                 .need_dac_fix = 1,
9356         },
9357         [ALC889_INTEL] = {
9358                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9359                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9360                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9361                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9362                 .dac_nids = alc883_dac_nids,
9363                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9364                 .adc_nids = alc889_adc_nids,
9365                 .dig_out_nid = ALC883_DIGOUT_NID,
9366                 .dig_in_nid = ALC883_DIGIN_NID,
9367                 .slave_dig_outs = alc883_slave_dig_outs,
9368                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9369                 .channel_mode = alc889_8ch_intel_modes,
9370                 .capsrc_nids = alc889_capsrc_nids,
9371                 .input_mux = &alc889_capture_source,
9372                 .setup = alc889_automute_setup,
9373                 .init_hook = alc889_intel_init_hook,
9374                 .unsol_event = alc_automute_amp_unsol_event,
9375                 .need_dac_fix = 1,
9376         },
9377         [ALC883_6ST_DIG] = {
9378                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9379                 .init_verbs = { alc883_init_verbs },
9380                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9381                 .dac_nids = alc883_dac_nids,
9382                 .dig_out_nid = ALC883_DIGOUT_NID,
9383                 .dig_in_nid = ALC883_DIGIN_NID,
9384                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9385                 .channel_mode = alc883_sixstack_modes,
9386                 .input_mux = &alc883_capture_source,
9387         },
9388         [ALC883_TARGA_DIG] = {
9389                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9390                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9391                                 alc883_targa_verbs},
9392                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9393                 .dac_nids = alc883_dac_nids,
9394                 .dig_out_nid = ALC883_DIGOUT_NID,
9395                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9396                 .channel_mode = alc883_3ST_6ch_modes,
9397                 .need_dac_fix = 1,
9398                 .input_mux = &alc883_capture_source,
9399                 .unsol_event = alc883_targa_unsol_event,
9400                 .setup = alc882_targa_setup,
9401                 .init_hook = alc882_targa_automute,
9402         },
9403         [ALC883_TARGA_2ch_DIG] = {
9404                 .mixers = { alc883_targa_2ch_mixer},
9405                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9406                                 alc883_targa_verbs},
9407                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9408                 .dac_nids = alc883_dac_nids,
9409                 .adc_nids = alc883_adc_nids_alt,
9410                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9411                 .capsrc_nids = alc883_capsrc_nids,
9412                 .dig_out_nid = ALC883_DIGOUT_NID,
9413                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9414                 .channel_mode = alc883_3ST_2ch_modes,
9415                 .input_mux = &alc883_capture_source,
9416                 .unsol_event = alc883_targa_unsol_event,
9417                 .setup = alc882_targa_setup,
9418                 .init_hook = alc882_targa_automute,
9419         },
9420         [ALC883_TARGA_8ch_DIG] = {
9421                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9422                             alc883_chmode_mixer },
9423                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9424                                 alc883_targa_verbs },
9425                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9426                 .dac_nids = alc883_dac_nids,
9427                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9428                 .adc_nids = alc883_adc_nids_rev,
9429                 .capsrc_nids = alc883_capsrc_nids_rev,
9430                 .dig_out_nid = ALC883_DIGOUT_NID,
9431                 .dig_in_nid = ALC883_DIGIN_NID,
9432                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9433                 .channel_mode = alc883_4ST_8ch_modes,
9434                 .need_dac_fix = 1,
9435                 .input_mux = &alc883_capture_source,
9436                 .unsol_event = alc883_targa_unsol_event,
9437                 .setup = alc882_targa_setup,
9438                 .init_hook = alc882_targa_automute,
9439         },
9440         [ALC883_ACER] = {
9441                 .mixers = { alc883_base_mixer },
9442                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9443                  * and the headphone jack.  Turn this on and rely on the
9444                  * standard mute methods whenever the user wants to turn
9445                  * these outputs off.
9446                  */
9447                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9448                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9449                 .dac_nids = alc883_dac_nids,
9450                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9451                 .channel_mode = alc883_3ST_2ch_modes,
9452                 .input_mux = &alc883_capture_source,
9453         },
9454         [ALC883_ACER_ASPIRE] = {
9455                 .mixers = { alc883_acer_aspire_mixer },
9456                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9457                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9458                 .dac_nids = alc883_dac_nids,
9459                 .dig_out_nid = ALC883_DIGOUT_NID,
9460                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9461                 .channel_mode = alc883_3ST_2ch_modes,
9462                 .input_mux = &alc883_capture_source,
9463                 .unsol_event = alc_automute_amp_unsol_event,
9464                 .setup = alc883_acer_aspire_setup,
9465                 .init_hook = alc_automute_amp,
9466         },
9467         [ALC888_ACER_ASPIRE_4930G] = {
9468                 .mixers = { alc888_base_mixer,
9469                                 alc883_chmode_mixer },
9470                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9471                                 alc888_acer_aspire_4930g_verbs },
9472                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9473                 .dac_nids = alc883_dac_nids,
9474                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9475                 .adc_nids = alc883_adc_nids_rev,
9476                 .capsrc_nids = alc883_capsrc_nids_rev,
9477                 .dig_out_nid = ALC883_DIGOUT_NID,
9478                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9479                 .channel_mode = alc883_3ST_6ch_modes,
9480                 .need_dac_fix = 1,
9481                 .const_channel_count = 6,
9482                 .num_mux_defs =
9483                         ARRAY_SIZE(alc888_2_capture_sources),
9484                 .input_mux = alc888_2_capture_sources,
9485                 .unsol_event = alc_automute_amp_unsol_event,
9486                 .setup = alc888_acer_aspire_4930g_setup,
9487                 .init_hook = alc_automute_amp,
9488         },
9489         [ALC888_ACER_ASPIRE_6530G] = {
9490                 .mixers = { alc888_acer_aspire_6530_mixer },
9491                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9492                                 alc888_acer_aspire_6530g_verbs },
9493                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9494                 .dac_nids = alc883_dac_nids,
9495                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9496                 .adc_nids = alc883_adc_nids_rev,
9497                 .capsrc_nids = alc883_capsrc_nids_rev,
9498                 .dig_out_nid = ALC883_DIGOUT_NID,
9499                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9500                 .channel_mode = alc883_3ST_2ch_modes,
9501                 .num_mux_defs =
9502                         ARRAY_SIZE(alc888_2_capture_sources),
9503                 .input_mux = alc888_acer_aspire_6530_sources,
9504                 .unsol_event = alc_automute_amp_unsol_event,
9505                 .setup = alc888_acer_aspire_6530g_setup,
9506                 .init_hook = alc_automute_amp,
9507         },
9508         [ALC888_ACER_ASPIRE_8930G] = {
9509                 .mixers = { alc889_acer_aspire_8930g_mixer,
9510                                 alc883_chmode_mixer },
9511                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9512                                 alc889_acer_aspire_8930g_verbs,
9513                                 alc889_eapd_verbs},
9514                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9515                 .dac_nids = alc883_dac_nids,
9516                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9517                 .adc_nids = alc889_adc_nids,
9518                 .capsrc_nids = alc889_capsrc_nids,
9519                 .dig_out_nid = ALC883_DIGOUT_NID,
9520                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9521                 .channel_mode = alc883_3ST_6ch_modes,
9522                 .need_dac_fix = 1,
9523                 .const_channel_count = 6,
9524                 .num_mux_defs =
9525                         ARRAY_SIZE(alc889_capture_sources),
9526                 .input_mux = alc889_capture_sources,
9527                 .unsol_event = alc_automute_amp_unsol_event,
9528                 .setup = alc889_acer_aspire_8930g_setup,
9529                 .init_hook = alc_automute_amp,
9530 #ifdef CONFIG_SND_HDA_POWER_SAVE
9531                 .power_hook = alc889_power_eapd,
9532 #endif
9533         },
9534         [ALC888_ACER_ASPIRE_7730G] = {
9535                 .mixers = { alc883_3ST_6ch_mixer,
9536                                 alc883_chmode_mixer },
9537                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9538                                 alc888_acer_aspire_7730G_verbs },
9539                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9540                 .dac_nids = alc883_dac_nids,
9541                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9542                 .adc_nids = alc883_adc_nids_rev,
9543                 .capsrc_nids = alc883_capsrc_nids_rev,
9544                 .dig_out_nid = ALC883_DIGOUT_NID,
9545                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9546                 .channel_mode = alc883_3ST_6ch_modes,
9547                 .need_dac_fix = 1,
9548                 .const_channel_count = 6,
9549                 .input_mux = &alc883_capture_source,
9550                 .unsol_event = alc_automute_amp_unsol_event,
9551                 .setup = alc888_acer_aspire_6530g_setup,
9552                 .init_hook = alc_automute_amp,
9553         },
9554         [ALC883_MEDION] = {
9555                 .mixers = { alc883_fivestack_mixer,
9556                             alc883_chmode_mixer },
9557                 .init_verbs = { alc883_init_verbs,
9558                                 alc883_medion_eapd_verbs },
9559                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9560                 .dac_nids = alc883_dac_nids,
9561                 .adc_nids = alc883_adc_nids_alt,
9562                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9563                 .capsrc_nids = alc883_capsrc_nids,
9564                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9565                 .channel_mode = alc883_sixstack_modes,
9566                 .input_mux = &alc883_capture_source,
9567         },
9568         [ALC883_MEDION_MD2] = {
9569                 .mixers = { alc883_medion_md2_mixer},
9570                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9571                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9572                 .dac_nids = alc883_dac_nids,
9573                 .dig_out_nid = ALC883_DIGOUT_NID,
9574                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9575                 .channel_mode = alc883_3ST_2ch_modes,
9576                 .input_mux = &alc883_capture_source,
9577                 .unsol_event = alc_automute_amp_unsol_event,
9578                 .setup = alc883_medion_md2_setup,
9579                 .init_hook = alc_automute_amp,
9580         },
9581         [ALC883_LAPTOP_EAPD] = {
9582                 .mixers = { alc883_base_mixer },
9583                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9584                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9585                 .dac_nids = alc883_dac_nids,
9586                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9587                 .channel_mode = alc883_3ST_2ch_modes,
9588                 .input_mux = &alc883_capture_source,
9589         },
9590         [ALC883_CLEVO_M540R] = {
9591                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9592                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9593                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9594                 .dac_nids = alc883_dac_nids,
9595                 .dig_out_nid = ALC883_DIGOUT_NID,
9596                 .dig_in_nid = ALC883_DIGIN_NID,
9597                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9598                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9599                 .need_dac_fix = 1,
9600                 .input_mux = &alc883_capture_source,
9601                 /* This machine has the hardware HP auto-muting, thus
9602                  * we need no software mute via unsol event
9603                  */
9604         },
9605         [ALC883_CLEVO_M720] = {
9606                 .mixers = { alc883_clevo_m720_mixer },
9607                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9608                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9609                 .dac_nids = alc883_dac_nids,
9610                 .dig_out_nid = ALC883_DIGOUT_NID,
9611                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9612                 .channel_mode = alc883_3ST_2ch_modes,
9613                 .input_mux = &alc883_capture_source,
9614                 .unsol_event = alc883_clevo_m720_unsol_event,
9615                 .setup = alc883_clevo_m720_setup,
9616                 .init_hook = alc883_clevo_m720_init_hook,
9617         },
9618         [ALC883_LENOVO_101E_2ch] = {
9619                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9620                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9621                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9622                 .dac_nids = alc883_dac_nids,
9623                 .adc_nids = alc883_adc_nids_alt,
9624                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9625                 .capsrc_nids = alc883_capsrc_nids,
9626                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9627                 .channel_mode = alc883_3ST_2ch_modes,
9628                 .input_mux = &alc883_lenovo_101e_capture_source,
9629                 .unsol_event = alc883_lenovo_101e_unsol_event,
9630                 .init_hook = alc883_lenovo_101e_all_automute,
9631         },
9632         [ALC883_LENOVO_NB0763] = {
9633                 .mixers = { alc883_lenovo_nb0763_mixer },
9634                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9635                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9636                 .dac_nids = alc883_dac_nids,
9637                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9638                 .channel_mode = alc883_3ST_2ch_modes,
9639                 .need_dac_fix = 1,
9640                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9641                 .unsol_event = alc_automute_amp_unsol_event,
9642                 .setup = alc883_medion_md2_setup,
9643                 .init_hook = alc_automute_amp,
9644         },
9645         [ALC888_LENOVO_MS7195_DIG] = {
9646                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9647                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9648                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9649                 .dac_nids = alc883_dac_nids,
9650                 .dig_out_nid = ALC883_DIGOUT_NID,
9651                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9652                 .channel_mode = alc883_3ST_6ch_modes,
9653                 .need_dac_fix = 1,
9654                 .input_mux = &alc883_capture_source,
9655                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9656                 .init_hook = alc888_lenovo_ms7195_front_automute,
9657         },
9658         [ALC883_HAIER_W66] = {
9659                 .mixers = { alc883_targa_2ch_mixer},
9660                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9661                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9662                 .dac_nids = alc883_dac_nids,
9663                 .dig_out_nid = ALC883_DIGOUT_NID,
9664                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9665                 .channel_mode = alc883_3ST_2ch_modes,
9666                 .input_mux = &alc883_capture_source,
9667                 .unsol_event = alc_automute_amp_unsol_event,
9668                 .setup = alc883_haier_w66_setup,
9669                 .init_hook = alc_automute_amp,
9670         },
9671         [ALC888_3ST_HP] = {
9672                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9673                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9674                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9675                 .dac_nids = alc883_dac_nids,
9676                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9677                 .channel_mode = alc888_3st_hp_modes,
9678                 .need_dac_fix = 1,
9679                 .input_mux = &alc883_capture_source,
9680                 .unsol_event = alc_automute_amp_unsol_event,
9681                 .setup = alc888_3st_hp_setup,
9682                 .init_hook = alc_automute_amp,
9683         },
9684         [ALC888_6ST_DELL] = {
9685                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9686                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9687                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9688                 .dac_nids = alc883_dac_nids,
9689                 .dig_out_nid = ALC883_DIGOUT_NID,
9690                 .dig_in_nid = ALC883_DIGIN_NID,
9691                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9692                 .channel_mode = alc883_sixstack_modes,
9693                 .input_mux = &alc883_capture_source,
9694                 .unsol_event = alc_automute_amp_unsol_event,
9695                 .setup = alc888_6st_dell_setup,
9696                 .init_hook = alc_automute_amp,
9697         },
9698         [ALC883_MITAC] = {
9699                 .mixers = { alc883_mitac_mixer },
9700                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9701                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9702                 .dac_nids = alc883_dac_nids,
9703                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9704                 .channel_mode = alc883_3ST_2ch_modes,
9705                 .input_mux = &alc883_capture_source,
9706                 .unsol_event = alc_automute_amp_unsol_event,
9707                 .setup = alc883_mitac_setup,
9708                 .init_hook = alc_automute_amp,
9709         },
9710         [ALC883_FUJITSU_PI2515] = {
9711                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9712                 .init_verbs = { alc883_init_verbs,
9713                                 alc883_2ch_fujitsu_pi2515_verbs},
9714                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9715                 .dac_nids = alc883_dac_nids,
9716                 .dig_out_nid = ALC883_DIGOUT_NID,
9717                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9718                 .channel_mode = alc883_3ST_2ch_modes,
9719                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9720                 .unsol_event = alc_automute_amp_unsol_event,
9721                 .setup = alc883_2ch_fujitsu_pi2515_setup,
9722                 .init_hook = alc_automute_amp,
9723         },
9724         [ALC888_FUJITSU_XA3530] = {
9725                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9726                 .init_verbs = { alc883_init_verbs,
9727                         alc888_fujitsu_xa3530_verbs },
9728                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9729                 .dac_nids = alc883_dac_nids,
9730                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9731                 .adc_nids = alc883_adc_nids_rev,
9732                 .capsrc_nids = alc883_capsrc_nids_rev,
9733                 .dig_out_nid = ALC883_DIGOUT_NID,
9734                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9735                 .channel_mode = alc888_4ST_8ch_intel_modes,
9736                 .num_mux_defs =
9737                         ARRAY_SIZE(alc888_2_capture_sources),
9738                 .input_mux = alc888_2_capture_sources,
9739                 .unsol_event = alc_automute_amp_unsol_event,
9740                 .setup = alc888_fujitsu_xa3530_setup,
9741                 .init_hook = alc_automute_amp,
9742         },
9743         [ALC888_LENOVO_SKY] = {
9744                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9745                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9746                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9747                 .dac_nids = alc883_dac_nids,
9748                 .dig_out_nid = ALC883_DIGOUT_NID,
9749                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9750                 .channel_mode = alc883_sixstack_modes,
9751                 .need_dac_fix = 1,
9752                 .input_mux = &alc883_lenovo_sky_capture_source,
9753                 .unsol_event = alc_automute_amp_unsol_event,
9754                 .setup = alc888_lenovo_sky_setup,
9755                 .init_hook = alc_automute_amp,
9756         },
9757         [ALC888_ASUS_M90V] = {
9758                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9759                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9760                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9761                 .dac_nids = alc883_dac_nids,
9762                 .dig_out_nid = ALC883_DIGOUT_NID,
9763                 .dig_in_nid = ALC883_DIGIN_NID,
9764                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9765                 .channel_mode = alc883_3ST_6ch_modes,
9766                 .need_dac_fix = 1,
9767                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9768                 .unsol_event = alc_sku_unsol_event,
9769                 .setup = alc883_mode2_setup,
9770                 .init_hook = alc_inithook,
9771         },
9772         [ALC888_ASUS_EEE1601] = {
9773                 .mixers = { alc883_asus_eee1601_mixer },
9774                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9775                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9776                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9777                 .dac_nids = alc883_dac_nids,
9778                 .dig_out_nid = ALC883_DIGOUT_NID,
9779                 .dig_in_nid = ALC883_DIGIN_NID,
9780                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9781                 .channel_mode = alc883_3ST_2ch_modes,
9782                 .need_dac_fix = 1,
9783                 .input_mux = &alc883_asus_eee1601_capture_source,
9784                 .unsol_event = alc_sku_unsol_event,
9785                 .init_hook = alc883_eee1601_inithook,
9786         },
9787         [ALC1200_ASUS_P5Q] = {
9788                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9789                 .init_verbs = { alc883_init_verbs },
9790                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9791                 .dac_nids = alc883_dac_nids,
9792                 .dig_out_nid = ALC1200_DIGOUT_NID,
9793                 .dig_in_nid = ALC883_DIGIN_NID,
9794                 .slave_dig_outs = alc1200_slave_dig_outs,
9795                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9796                 .channel_mode = alc883_sixstack_modes,
9797                 .input_mux = &alc883_capture_source,
9798         },
9799         [ALC889A_MB31] = {
9800                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9801                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9802                         alc880_gpio1_init_verbs },
9803                 .adc_nids = alc883_adc_nids,
9804                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9805                 .capsrc_nids = alc883_capsrc_nids,
9806                 .dac_nids = alc883_dac_nids,
9807                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9808                 .channel_mode = alc889A_mb31_6ch_modes,
9809                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9810                 .input_mux = &alc889A_mb31_capture_source,
9811                 .dig_out_nid = ALC883_DIGOUT_NID,
9812                 .unsol_event = alc889A_mb31_unsol_event,
9813                 .init_hook = alc889A_mb31_automute,
9814         },
9815         [ALC883_SONY_VAIO_TT] = {
9816                 .mixers = { alc883_vaiott_mixer },
9817                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9818                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9819                 .dac_nids = alc883_dac_nids,
9820                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9821                 .channel_mode = alc883_3ST_2ch_modes,
9822                 .input_mux = &alc883_capture_source,
9823                 .unsol_event = alc_automute_amp_unsol_event,
9824                 .setup = alc883_vaiott_setup,
9825                 .init_hook = alc_automute_amp,
9826         },
9827 };
9828
9829
9830 /*
9831  * Pin config fixes
9832  */
9833 enum {
9834         PINFIX_ABIT_AW9D_MAX
9835 };
9836
9837 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9838         { 0x15, 0x01080104 }, /* side */
9839         { 0x16, 0x01011012 }, /* rear */
9840         { 0x17, 0x01016011 }, /* clfe */
9841         { }
9842 };
9843
9844 static const struct alc_fixup alc882_fixups[] = {
9845         [PINFIX_ABIT_AW9D_MAX] = {
9846                 .pins = alc882_abit_aw9d_pinfix
9847         },
9848 };
9849
9850 static struct snd_pci_quirk alc882_fixup_tbl[] = {
9851         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9852         {}
9853 };
9854
9855 /*
9856  * BIOS auto configuration
9857  */
9858 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
9859                                                 const struct auto_pin_cfg *cfg)
9860 {
9861         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
9862 }
9863
9864 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9865                                               hda_nid_t nid, int pin_type,
9866                                               int dac_idx)
9867 {
9868         /* set as output */
9869         struct alc_spec *spec = codec->spec;
9870         int idx;
9871
9872         alc_set_pin_output(codec, nid, pin_type);
9873         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9874                 idx = 4;
9875         else
9876                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9877         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9878
9879 }
9880
9881 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9882 {
9883         struct alc_spec *spec = codec->spec;
9884         int i;
9885
9886         for (i = 0; i <= HDA_SIDE; i++) {
9887                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9888                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9889                 if (nid)
9890                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9891                                                           i);
9892         }
9893 }
9894
9895 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9896 {
9897         struct alc_spec *spec = codec->spec;
9898         hda_nid_t pin;
9899
9900         pin = spec->autocfg.hp_pins[0];
9901         if (pin) /* connect to front */
9902                 /* use dac 0 */
9903                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9904         pin = spec->autocfg.speaker_pins[0];
9905         if (pin)
9906                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9907 }
9908
9909 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9910 {
9911         struct alc_spec *spec = codec->spec;
9912         int i;
9913
9914         for (i = 0; i < AUTO_PIN_LAST; i++) {
9915                 hda_nid_t nid = spec->autocfg.input_pins[i];
9916                 if (!nid)
9917                         continue;
9918                 alc_set_input_pin(codec, nid, i);
9919                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9920                         snd_hda_codec_write(codec, nid, 0,
9921                                             AC_VERB_SET_AMP_GAIN_MUTE,
9922                                             AMP_OUT_MUTE);
9923         }
9924 }
9925
9926 static void alc882_auto_init_input_src(struct hda_codec *codec)
9927 {
9928         struct alc_spec *spec = codec->spec;
9929         int c;
9930
9931         for (c = 0; c < spec->num_adc_nids; c++) {
9932                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9933                 hda_nid_t nid = spec->capsrc_nids[c];
9934                 unsigned int mux_idx;
9935                 const struct hda_input_mux *imux;
9936                 int conns, mute, idx, item;
9937
9938                 conns = snd_hda_get_connections(codec, nid, conn_list,
9939                                                 ARRAY_SIZE(conn_list));
9940                 if (conns < 0)
9941                         continue;
9942                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9943                 imux = &spec->input_mux[mux_idx];
9944                 for (idx = 0; idx < conns; idx++) {
9945                         /* if the current connection is the selected one,
9946                          * unmute it as default - otherwise mute it
9947                          */
9948                         mute = AMP_IN_MUTE(idx);
9949                         for (item = 0; item < imux->num_items; item++) {
9950                                 if (imux->items[item].index == idx) {
9951                                         if (spec->cur_mux[c] == item)
9952                                                 mute = AMP_IN_UNMUTE(idx);
9953                                         break;
9954                                 }
9955                         }
9956                         /* check if we have a selector or mixer
9957                          * we could check for the widget type instead, but
9958                          * just check for Amp-In presence (in case of mixer
9959                          * without amp-in there is something wrong, this
9960                          * function shouldn't be used or capsrc nid is wrong)
9961                          */
9962                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9963                                 snd_hda_codec_write(codec, nid, 0,
9964                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9965                                                     mute);
9966                         else if (mute != AMP_IN_MUTE(idx))
9967                                 snd_hda_codec_write(codec, nid, 0,
9968                                                     AC_VERB_SET_CONNECT_SEL,
9969                                                     idx);
9970                 }
9971         }
9972 }
9973
9974 /* add mic boosts if needed */
9975 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9976 {
9977         struct alc_spec *spec = codec->spec;
9978         int err;
9979         hda_nid_t nid;
9980
9981         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9982         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9983                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9984                                   "Mic Boost",
9985                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9986                 if (err < 0)
9987                         return err;
9988         }
9989         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9990         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9991                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9992                                   "Front Mic Boost",
9993                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9994                 if (err < 0)
9995                         return err;
9996         }
9997         return 0;
9998 }
9999
10000 /* almost identical with ALC880 parser... */
10001 static int alc882_parse_auto_config(struct hda_codec *codec)
10002 {
10003         struct alc_spec *spec = codec->spec;
10004         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10005         int i, err;
10006
10007         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10008                                            alc882_ignore);
10009         if (err < 0)
10010                 return err;
10011         if (!spec->autocfg.line_outs)
10012                 return 0; /* can't find valid BIOS pin config */
10013
10014         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10015         if (err < 0)
10016                 return err;
10017         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10018         if (err < 0)
10019                 return err;
10020         err = alc880_auto_create_extra_out(spec,
10021                                            spec->autocfg.speaker_pins[0],
10022                                            "Speaker");
10023         if (err < 0)
10024                 return err;
10025         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10026                                            "Headphone");
10027         if (err < 0)
10028                 return err;
10029         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10030         if (err < 0)
10031                 return err;
10032
10033         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10034
10035         /* check multiple SPDIF-out (for recent codecs) */
10036         for (i = 0; i < spec->autocfg.dig_outs; i++) {
10037                 hda_nid_t dig_nid;
10038                 err = snd_hda_get_connections(codec,
10039                                               spec->autocfg.dig_out_pins[i],
10040                                               &dig_nid, 1);
10041                 if (err < 0)
10042                         continue;
10043                 if (!i)
10044                         spec->multiout.dig_out_nid = dig_nid;
10045                 else {
10046                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
10047                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
10048                                 break;
10049                         spec->slave_dig_outs[i - 1] = dig_nid;
10050                 }
10051         }
10052         if (spec->autocfg.dig_in_pin)
10053                 spec->dig_in_nid = ALC880_DIGIN_NID;
10054
10055         if (spec->kctls.list)
10056                 add_mixer(spec, spec->kctls.list);
10057
10058         add_verb(spec, alc883_auto_init_verbs);
10059         /* if ADC 0x07 is available, initialize it, too */
10060         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10061                 add_verb(spec, alc882_adc1_init_verbs);
10062
10063         spec->num_mux_defs = 1;
10064         spec->input_mux = &spec->private_imux[0];
10065
10066         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
10067
10068         err = alc_auto_add_mic_boost(codec);
10069         if (err < 0)
10070                 return err;
10071
10072         return 1; /* config found */
10073 }
10074
10075 /* additional initialization for auto-configuration model */
10076 static void alc882_auto_init(struct hda_codec *codec)
10077 {
10078         struct alc_spec *spec = codec->spec;
10079         alc882_auto_init_multi_out(codec);
10080         alc882_auto_init_hp_out(codec);
10081         alc882_auto_init_analog_input(codec);
10082         alc882_auto_init_input_src(codec);
10083         if (spec->unsol_event)
10084                 alc_inithook(codec);
10085 }
10086
10087 static int patch_alc882(struct hda_codec *codec)
10088 {
10089         struct alc_spec *spec;
10090         int err, board_config;
10091
10092         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10093         if (spec == NULL)
10094                 return -ENOMEM;
10095
10096         codec->spec = spec;
10097
10098         switch (codec->vendor_id) {
10099         case 0x10ec0882:
10100         case 0x10ec0885:
10101                 break;
10102         default:
10103                 /* ALC883 and variants */
10104                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10105                 break;
10106         }
10107
10108         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10109                                                   alc882_models,
10110                                                   alc882_cfg_tbl);
10111
10112         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10113                 board_config = snd_hda_check_board_codec_sid_config(codec,
10114                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10115
10116         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10117                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10118                        codec->chip_name);
10119                 board_config = ALC882_AUTO;
10120         }
10121
10122         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10123
10124         if (board_config == ALC882_AUTO) {
10125                 /* automatic parse from the BIOS config */
10126                 err = alc882_parse_auto_config(codec);
10127                 if (err < 0) {
10128                         alc_free(codec);
10129                         return err;
10130                 } else if (!err) {
10131                         printk(KERN_INFO
10132                                "hda_codec: Cannot set up configuration "
10133                                "from BIOS.  Using base mode...\n");
10134                         board_config = ALC882_3ST_DIG;
10135                 }
10136         }
10137
10138         err = snd_hda_attach_beep_device(codec, 0x1);
10139         if (err < 0) {
10140                 alc_free(codec);
10141                 return err;
10142         }
10143
10144         if (board_config != ALC882_AUTO)
10145                 setup_preset(codec, &alc882_presets[board_config]);
10146
10147         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10148         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10149         /* FIXME: setup DAC5 */
10150         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10151         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10152
10153         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10154         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10155
10156         if (codec->vendor_id == 0x10ec0888)
10157                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10158
10159         if (!spec->adc_nids && spec->input_mux) {
10160                 int i, j;
10161                 spec->num_adc_nids = 0;
10162                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10163                         const struct hda_input_mux *imux = spec->input_mux;
10164                         hda_nid_t cap;
10165                         hda_nid_t items[16];
10166                         hda_nid_t nid = alc882_adc_nids[i];
10167                         unsigned int wcap = get_wcaps(codec, nid);
10168                         /* get type */
10169                         wcap = get_wcaps_type(wcap);
10170                         if (wcap != AC_WID_AUD_IN)
10171                                 continue;
10172                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10173                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10174                         if (err < 0)
10175                                 continue;
10176                         err = snd_hda_get_connections(codec, cap, items,
10177                                                       ARRAY_SIZE(items));
10178                         if (err < 0)
10179                                 continue;
10180                         for (j = 0; j < imux->num_items; j++)
10181                                 if (imux->items[j].index >= err)
10182                                         break;
10183                         if (j < imux->num_items)
10184                                 continue;
10185                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10186                         spec->num_adc_nids++;
10187                 }
10188                 spec->adc_nids = spec->private_adc_nids;
10189                 spec->capsrc_nids = spec->private_capsrc_nids;
10190         }
10191
10192         set_capture_mixer(codec);
10193         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10194
10195         spec->vmaster_nid = 0x0c;
10196
10197         codec->patch_ops = alc_patch_ops;
10198         if (board_config == ALC882_AUTO)
10199                 spec->init_hook = alc882_auto_init;
10200 #ifdef CONFIG_SND_HDA_POWER_SAVE
10201         if (!spec->loopback.amplist)
10202                 spec->loopback.amplist = alc882_loopbacks;
10203 #endif
10204         codec->proc_widget_hook = print_realtek_coef;
10205
10206         return 0;
10207 }
10208
10209
10210 /*
10211  * ALC262 support
10212  */
10213
10214 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10215 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10216
10217 #define alc262_dac_nids         alc260_dac_nids
10218 #define alc262_adc_nids         alc882_adc_nids
10219 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10220 #define alc262_capsrc_nids      alc882_capsrc_nids
10221 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10222
10223 #define alc262_modes            alc260_modes
10224 #define alc262_capture_source   alc882_capture_source
10225
10226 static hda_nid_t alc262_dmic_adc_nids[1] = {
10227         /* ADC0 */
10228         0x09
10229 };
10230
10231 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10232
10233 static struct snd_kcontrol_new alc262_base_mixer[] = {
10234         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10235         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10236         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10237         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10238         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10239         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10240         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10241         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10242         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10243         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10244         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10245         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10246         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10247         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10248         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10249         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10250         { } /* end */
10251 };
10252
10253 /* update HP, line and mono-out pins according to the master switch */
10254 static void alc262_hp_master_update(struct hda_codec *codec)
10255 {
10256         struct alc_spec *spec = codec->spec;
10257         int val = spec->master_sw;
10258
10259         /* HP & line-out */
10260         snd_hda_codec_write_cache(codec, 0x1b, 0,
10261                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10262                                   val ? PIN_HP : 0);
10263         snd_hda_codec_write_cache(codec, 0x15, 0,
10264                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10265                                   val ? PIN_HP : 0);
10266         /* mono (speaker) depending on the HP jack sense */
10267         val = val && !spec->jack_present;
10268         snd_hda_codec_write_cache(codec, 0x16, 0,
10269                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10270                                   val ? PIN_OUT : 0);
10271 }
10272
10273 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10274 {
10275         struct alc_spec *spec = codec->spec;
10276
10277         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10278         alc262_hp_master_update(codec);
10279 }
10280
10281 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10282 {
10283         if ((res >> 26) != ALC880_HP_EVENT)
10284                 return;
10285         alc262_hp_bpc_automute(codec);
10286 }
10287
10288 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10289 {
10290         struct alc_spec *spec = codec->spec;
10291
10292         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10293         alc262_hp_master_update(codec);
10294 }
10295
10296 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10297                                            unsigned int res)
10298 {
10299         if ((res >> 26) != ALC880_HP_EVENT)
10300                 return;
10301         alc262_hp_wildwest_automute(codec);
10302 }
10303
10304 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10305
10306 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10307                                    struct snd_ctl_elem_value *ucontrol)
10308 {
10309         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10310         struct alc_spec *spec = codec->spec;
10311         int val = !!*ucontrol->value.integer.value;
10312
10313         if (val == spec->master_sw)
10314                 return 0;
10315         spec->master_sw = val;
10316         alc262_hp_master_update(codec);
10317         return 1;
10318 }
10319
10320 #define ALC262_HP_MASTER_SWITCH                                 \
10321         {                                                       \
10322                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10323                 .name = "Master Playback Switch",               \
10324                 .info = snd_ctl_boolean_mono_info,              \
10325                 .get = alc262_hp_master_sw_get,                 \
10326                 .put = alc262_hp_master_sw_put,                 \
10327         }
10328
10329 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10330         ALC262_HP_MASTER_SWITCH,
10331         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10332         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10333         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10334         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10335                               HDA_OUTPUT),
10336         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10337                             HDA_OUTPUT),
10338         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10339         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10340         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10341         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10342         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10343         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10344         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10345         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10346         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10347         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10348         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10349         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10350         { } /* end */
10351 };
10352
10353 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10354         ALC262_HP_MASTER_SWITCH,
10355         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10356         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10357         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10358         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10359         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10360                               HDA_OUTPUT),
10361         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10362                             HDA_OUTPUT),
10363         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10364         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10365         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10366         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10367         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10368         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10369         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10370         { } /* end */
10371 };
10372
10373 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10374         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10375         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10376         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10377         { } /* end */
10378 };
10379
10380 /* mute/unmute internal speaker according to the hp jack and mute state */
10381 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10382 {
10383         struct alc_spec *spec = codec->spec;
10384
10385         spec->autocfg.hp_pins[0] = 0x15;
10386         spec->autocfg.speaker_pins[0] = 0x14;
10387 }
10388
10389 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10390         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10391         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10392         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10393         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10394         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10395         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10396         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10397         { } /* end */
10398 };
10399
10400 static struct hda_verb alc262_hp_t5735_verbs[] = {
10401         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10402         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10403
10404         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10405         { }
10406 };
10407
10408 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10409         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10410         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10411         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10412         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10413         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10414         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10415         { } /* end */
10416 };
10417
10418 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10419         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10420         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10421         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10422         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10423         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10424         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10425         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10426         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10427         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10428         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10429         {}
10430 };
10431
10432 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10433         .num_items = 1,
10434         .items = {
10435                 { "Line", 0x1 },
10436         },
10437 };
10438
10439 /* bind hp and internal speaker mute (with plug check) as master switch */
10440 static void alc262_hippo_master_update(struct hda_codec *codec)
10441 {
10442         struct alc_spec *spec = codec->spec;
10443         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10444         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10445         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10446         unsigned int mute;
10447
10448         /* HP */
10449         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10450         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10451                                  HDA_AMP_MUTE, mute);
10452         /* mute internal speaker per jack sense */
10453         if (spec->jack_present)
10454                 mute = HDA_AMP_MUTE;
10455         if (line_nid)
10456                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10457                                          HDA_AMP_MUTE, mute);
10458         if (speaker_nid && speaker_nid != line_nid)
10459                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10460                                          HDA_AMP_MUTE, mute);
10461 }
10462
10463 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10464
10465 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10466                                       struct snd_ctl_elem_value *ucontrol)
10467 {
10468         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10469         struct alc_spec *spec = codec->spec;
10470         int val = !!*ucontrol->value.integer.value;
10471
10472         if (val == spec->master_sw)
10473                 return 0;
10474         spec->master_sw = val;
10475         alc262_hippo_master_update(codec);
10476         return 1;
10477 }
10478
10479 #define ALC262_HIPPO_MASTER_SWITCH                              \
10480         {                                                       \
10481                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10482                 .name = "Master Playback Switch",               \
10483                 .info = snd_ctl_boolean_mono_info,              \
10484                 .get = alc262_hippo_master_sw_get,              \
10485                 .put = alc262_hippo_master_sw_put,              \
10486         }
10487
10488 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10489         ALC262_HIPPO_MASTER_SWITCH,
10490         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10491         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10492         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10493         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10494         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10495         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10496         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10497         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10498         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10499         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10500         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10501         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10502         { } /* end */
10503 };
10504
10505 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10506         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10507         ALC262_HIPPO_MASTER_SWITCH,
10508         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10509         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10510         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10511         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10512         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10513         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10514         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10515         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10516         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10517         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10518         { } /* end */
10519 };
10520
10521 /* mute/unmute internal speaker according to the hp jack and mute state */
10522 static void alc262_hippo_automute(struct hda_codec *codec)
10523 {
10524         struct alc_spec *spec = codec->spec;
10525         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10526
10527         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10528         alc262_hippo_master_update(codec);
10529 }
10530
10531 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10532 {
10533         if ((res >> 26) != ALC880_HP_EVENT)
10534                 return;
10535         alc262_hippo_automute(codec);
10536 }
10537
10538 static void alc262_hippo_setup(struct hda_codec *codec)
10539 {
10540         struct alc_spec *spec = codec->spec;
10541
10542         spec->autocfg.hp_pins[0] = 0x15;
10543         spec->autocfg.speaker_pins[0] = 0x14;
10544 }
10545
10546 static void alc262_hippo1_setup(struct hda_codec *codec)
10547 {
10548         struct alc_spec *spec = codec->spec;
10549
10550         spec->autocfg.hp_pins[0] = 0x1b;
10551         spec->autocfg.speaker_pins[0] = 0x14;
10552 }
10553
10554
10555 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10556         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10557         ALC262_HIPPO_MASTER_SWITCH,
10558         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10559         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10560         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10561         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10562         { } /* end */
10563 };
10564
10565 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10566         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10567         ALC262_HIPPO_MASTER_SWITCH,
10568         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10569         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10570         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10571         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10572         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10573         { } /* end */
10574 };
10575
10576 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10577         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10578         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10579         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10580         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10581         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10582         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10583         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10584         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10585         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10586         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10587         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10588         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10589         { } /* end */
10590 };
10591
10592 static struct hda_verb alc262_tyan_verbs[] = {
10593         /* Headphone automute */
10594         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10595         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10596         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10597
10598         /* P11 AUX_IN, white 4-pin connector */
10599         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10600         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10601         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10602         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10603
10604         {}
10605 };
10606
10607 /* unsolicited event for HP jack sensing */
10608 static void alc262_tyan_setup(struct hda_codec *codec)
10609 {
10610         struct alc_spec *spec = codec->spec;
10611
10612         spec->autocfg.hp_pins[0] = 0x1b;
10613         spec->autocfg.speaker_pins[0] = 0x15;
10614 }
10615
10616
10617 #define alc262_capture_mixer            alc882_capture_mixer
10618 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10619
10620 /*
10621  * generic initialization of ADC, input mixers and output mixers
10622  */
10623 static struct hda_verb alc262_init_verbs[] = {
10624         /*
10625          * Unmute ADC0-2 and set the default input to mic-in
10626          */
10627         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10628         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10629         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10630         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10631         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10632         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10633
10634         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10635          * mixer widget
10636          * Note: PASD motherboards uses the Line In 2 as the input for
10637          * front panel mic (mic 2)
10638          */
10639         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10640         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10641         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10642         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10643         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10644         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10645
10646         /*
10647          * Set up output mixers (0x0c - 0x0e)
10648          */
10649         /* set vol=0 to output mixers */
10650         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10651         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10652         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10653         /* set up input amps for analog loopback */
10654         /* Amp Indices: DAC = 0, mixer = 1 */
10655         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10656         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10657         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10658         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10659         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10660         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10661
10662         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10663         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10664         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10665         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10666         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10667         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10668
10669         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10670         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10671         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10672         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10673         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10674
10675         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10676         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10677
10678         /* FIXME: use matrix-type input source selection */
10679         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10680         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10681         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10682         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10683         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10684         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10685         /* Input mixer2 */
10686         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10687         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10688         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10689         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10690         /* Input mixer3 */
10691         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10692         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10693         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10694         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10695
10696         { }
10697 };
10698
10699 static struct hda_verb alc262_eapd_verbs[] = {
10700         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10701         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10702         { }
10703 };
10704
10705 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10706         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10707         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10708         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10709
10710         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10711         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10712         {}
10713 };
10714
10715 static struct hda_verb alc262_sony_unsol_verbs[] = {
10716         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10717         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10718         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10719
10720         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10721         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10722         {}
10723 };
10724
10725 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10726         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10727         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10728         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10729         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10730         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10731         { } /* end */
10732 };
10733
10734 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10735         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10736         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10737         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10738         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10739         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10740         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10741         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10742         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10743         {}
10744 };
10745
10746 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
10747 {
10748         struct alc_spec *spec = codec->spec;
10749
10750         spec->autocfg.hp_pins[0] = 0x15;
10751         spec->autocfg.speaker_pins[0] = 0x14;
10752         spec->ext_mic.pin = 0x18;
10753         spec->ext_mic.mux_idx = 0;
10754         spec->int_mic.pin = 0x12;
10755         spec->int_mic.mux_idx = 9;
10756         spec->auto_mic = 1;
10757 }
10758
10759 /*
10760  * nec model
10761  *  0x15 = headphone
10762  *  0x16 = internal speaker
10763  *  0x18 = external mic
10764  */
10765
10766 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10767         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10768         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10769
10770         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10771         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10772         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10773
10774         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10775         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10776         { } /* end */
10777 };
10778
10779 static struct hda_verb alc262_nec_verbs[] = {
10780         /* Unmute Speaker */
10781         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10782
10783         /* Headphone */
10784         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10785         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10786
10787         /* External mic to headphone */
10788         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10789         /* External mic to speaker */
10790         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10791         {}
10792 };
10793
10794 /*
10795  * fujitsu model
10796  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10797  *  0x1b = port replicator headphone out
10798  */
10799
10800 #define ALC_HP_EVENT    0x37
10801
10802 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10803         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10804         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10805         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10806         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10807         {}
10808 };
10809
10810 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10811         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10812         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10813         {}
10814 };
10815
10816 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
10817         /* Front Mic pin: input vref at 50% */
10818         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
10819         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10820         {}
10821 };
10822
10823 static struct hda_input_mux alc262_fujitsu_capture_source = {
10824         .num_items = 3,
10825         .items = {
10826                 { "Mic", 0x0 },
10827                 { "Int Mic", 0x1 },
10828                 { "CD", 0x4 },
10829         },
10830 };
10831
10832 static struct hda_input_mux alc262_HP_capture_source = {
10833         .num_items = 5,
10834         .items = {
10835                 { "Mic", 0x0 },
10836                 { "Front Mic", 0x1 },
10837                 { "Line", 0x2 },
10838                 { "CD", 0x4 },
10839                 { "AUX IN", 0x6 },
10840         },
10841 };
10842
10843 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10844         .num_items = 4,
10845         .items = {
10846                 { "Mic", 0x0 },
10847                 { "Front Mic", 0x2 },
10848                 { "Line", 0x1 },
10849                 { "CD", 0x4 },
10850         },
10851 };
10852
10853 /* mute/unmute internal speaker according to the hp jacks and mute state */
10854 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10855 {
10856         struct alc_spec *spec = codec->spec;
10857         unsigned int mute;
10858
10859         if (force || !spec->sense_updated) {
10860                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
10861                                      snd_hda_jack_detect(codec, 0x1b);
10862                 spec->sense_updated = 1;
10863         }
10864         /* unmute internal speaker only if both HPs are unplugged and
10865          * master switch is on
10866          */
10867         if (spec->jack_present)
10868                 mute = HDA_AMP_MUTE;
10869         else
10870                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10871         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10872                                  HDA_AMP_MUTE, mute);
10873 }
10874
10875 /* unsolicited event for HP jack sensing */
10876 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10877                                        unsigned int res)
10878 {
10879         if ((res >> 26) != ALC_HP_EVENT)
10880                 return;
10881         alc262_fujitsu_automute(codec, 1);
10882 }
10883
10884 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10885 {
10886         alc262_fujitsu_automute(codec, 1);
10887 }
10888
10889 /* bind volumes of both NID 0x0c and 0x0d */
10890 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10891         .ops = &snd_hda_bind_vol,
10892         .values = {
10893                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10894                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10895                 0
10896         },
10897 };
10898
10899 /* mute/unmute internal speaker according to the hp jack and mute state */
10900 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10901 {
10902         struct alc_spec *spec = codec->spec;
10903         unsigned int mute;
10904
10905         if (force || !spec->sense_updated) {
10906                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10907                 spec->sense_updated = 1;
10908         }
10909         if (spec->jack_present) {
10910                 /* mute internal speaker */
10911                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10912                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10913                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10914                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10915         } else {
10916                 /* unmute internal speaker if necessary */
10917                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10918                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10919                                          HDA_AMP_MUTE, mute);
10920                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10921                                          HDA_AMP_MUTE, mute);
10922         }
10923 }
10924
10925 /* unsolicited event for HP jack sensing */
10926 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10927                                        unsigned int res)
10928 {
10929         if ((res >> 26) != ALC_HP_EVENT)
10930                 return;
10931         alc262_lenovo_3000_automute(codec, 1);
10932 }
10933
10934 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10935                                   int dir, int idx, long *valp)
10936 {
10937         int i, change = 0;
10938
10939         for (i = 0; i < 2; i++, valp++)
10940                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10941                                                    HDA_AMP_MUTE,
10942                                                    *valp ? 0 : HDA_AMP_MUTE);
10943         return change;
10944 }
10945
10946 /* bind hp and internal speaker mute (with plug check) */
10947 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10948                                          struct snd_ctl_elem_value *ucontrol)
10949 {
10950         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10951         long *valp = ucontrol->value.integer.value;
10952         int change;
10953
10954         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10955         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10956         if (change)
10957                 alc262_fujitsu_automute(codec, 0);
10958         return change;
10959 }
10960
10961 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10962         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10963         {
10964                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10965                 .name = "Master Playback Switch",
10966                 .info = snd_hda_mixer_amp_switch_info,
10967                 .get = snd_hda_mixer_amp_switch_get,
10968                 .put = alc262_fujitsu_master_sw_put,
10969                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10970         },
10971         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10972         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10973         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10974         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10976         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10977         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10978         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10979         { } /* end */
10980 };
10981
10982 /* bind hp and internal speaker mute (with plug check) */
10983 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10984                                          struct snd_ctl_elem_value *ucontrol)
10985 {
10986         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10987         long *valp = ucontrol->value.integer.value;
10988         int change;
10989
10990         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10991         if (change)
10992                 alc262_lenovo_3000_automute(codec, 0);
10993         return change;
10994 }
10995
10996 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10997         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10998         {
10999                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11000                 .name = "Master Playback Switch",
11001                 .info = snd_hda_mixer_amp_switch_info,
11002                 .get = snd_hda_mixer_amp_switch_get,
11003                 .put = alc262_lenovo_3000_master_sw_put,
11004                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11005         },
11006         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11007         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11008         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11009         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11010         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11011         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11012         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11013         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11014         { } /* end */
11015 };
11016
11017 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11018         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11019         ALC262_HIPPO_MASTER_SWITCH,
11020         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11021         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11022         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11023         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11024         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11025         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11026         { } /* end */
11027 };
11028
11029 /* additional init verbs for Benq laptops */
11030 static struct hda_verb alc262_EAPD_verbs[] = {
11031         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11032         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11033         {}
11034 };
11035
11036 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11037         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11038         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11039
11040         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11041         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11042         {}
11043 };
11044
11045 /* Samsung Q1 Ultra Vista model setup */
11046 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11047         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11048         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11049         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11050         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11051         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11052         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11053         { } /* end */
11054 };
11055
11056 static struct hda_verb alc262_ultra_verbs[] = {
11057         /* output mixer */
11058         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11059         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11060         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11061         /* speaker */
11062         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11063         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11064         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11065         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11066         /* HP */
11067         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11068         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11069         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11070         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11071         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11072         /* internal mic */
11073         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11074         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11075         /* ADC, choose mic */
11076         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11077         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11078         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11079         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11080         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11081         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11082         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11083         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11084         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11085         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11086         {}
11087 };
11088
11089 /* mute/unmute internal speaker according to the hp jack and mute state */
11090 static void alc262_ultra_automute(struct hda_codec *codec)
11091 {
11092         struct alc_spec *spec = codec->spec;
11093         unsigned int mute;
11094
11095         mute = 0;
11096         /* auto-mute only when HP is used as HP */
11097         if (!spec->cur_mux[0]) {
11098                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11099                 if (spec->jack_present)
11100                         mute = HDA_AMP_MUTE;
11101         }
11102         /* mute/unmute internal speaker */
11103         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11104                                  HDA_AMP_MUTE, mute);
11105         /* mute/unmute HP */
11106         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11107                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11108 }
11109
11110 /* unsolicited event for HP jack sensing */
11111 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11112                                        unsigned int res)
11113 {
11114         if ((res >> 26) != ALC880_HP_EVENT)
11115                 return;
11116         alc262_ultra_automute(codec);
11117 }
11118
11119 static struct hda_input_mux alc262_ultra_capture_source = {
11120         .num_items = 2,
11121         .items = {
11122                 { "Mic", 0x1 },
11123                 { "Headphone", 0x7 },
11124         },
11125 };
11126
11127 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11128                                      struct snd_ctl_elem_value *ucontrol)
11129 {
11130         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11131         struct alc_spec *spec = codec->spec;
11132         int ret;
11133
11134         ret = alc_mux_enum_put(kcontrol, ucontrol);
11135         if (!ret)
11136                 return 0;
11137         /* reprogram the HP pin as mic or HP according to the input source */
11138         snd_hda_codec_write_cache(codec, 0x15, 0,
11139                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11140                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11141         alc262_ultra_automute(codec); /* mute/unmute HP */
11142         return ret;
11143 }
11144
11145 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11146         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11147         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11148         {
11149                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11150                 .name = "Capture Source",
11151                 .info = alc_mux_enum_info,
11152                 .get = alc_mux_enum_get,
11153                 .put = alc262_ultra_mux_enum_put,
11154         },
11155         { } /* end */
11156 };
11157
11158 /* We use two mixers depending on the output pin; 0x16 is a mono output
11159  * and thus it's bound with a different mixer.
11160  * This function returns which mixer amp should be used.
11161  */
11162 static int alc262_check_volbit(hda_nid_t nid)
11163 {
11164         if (!nid)
11165                 return 0;
11166         else if (nid == 0x16)
11167                 return 2;
11168         else
11169                 return 1;
11170 }
11171
11172 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11173                                   const char *pfx, int *vbits)
11174 {
11175         unsigned long val;
11176         int vbit;
11177
11178         vbit = alc262_check_volbit(nid);
11179         if (!vbit)
11180                 return 0;
11181         if (*vbits & vbit) /* a volume control for this mixer already there */
11182                 return 0;
11183         *vbits |= vbit;
11184         if (vbit == 2)
11185                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11186         else
11187                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11188         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11189 }
11190
11191 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11192                                  const char *pfx)
11193 {
11194         unsigned long val;
11195
11196         if (!nid)
11197                 return 0;
11198         if (nid == 0x16)
11199                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11200         else
11201                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11202         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11203 }
11204
11205 /* add playback controls from the parsed DAC table */
11206 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11207                                              const struct auto_pin_cfg *cfg)
11208 {
11209         const char *pfx;
11210         int vbits;
11211         int err;
11212
11213         spec->multiout.num_dacs = 1;    /* only use one dac */
11214         spec->multiout.dac_nids = spec->private_dac_nids;
11215         spec->multiout.dac_nids[0] = 2;
11216
11217         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11218                 pfx = "Master";
11219         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11220                 pfx = "Speaker";
11221         else
11222                 pfx = "Front";
11223         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11224         if (err < 0)
11225                 return err;
11226         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11227         if (err < 0)
11228                 return err;
11229         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11230         if (err < 0)
11231                 return err;
11232
11233         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11234                 alc262_check_volbit(cfg->speaker_pins[0]) |
11235                 alc262_check_volbit(cfg->hp_pins[0]);
11236         if (vbits == 1 || vbits == 2)
11237                 pfx = "Master"; /* only one mixer is used */
11238         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11239                 pfx = "Speaker";
11240         else
11241                 pfx = "Front";
11242         vbits = 0;
11243         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11244         if (err < 0)
11245                 return err;
11246         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11247                                      &vbits);
11248         if (err < 0)
11249                 return err;
11250         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11251                                      &vbits);
11252         if (err < 0)
11253                 return err;
11254         return 0;
11255 }
11256
11257 #define alc262_auto_create_input_ctls \
11258         alc882_auto_create_input_ctls
11259
11260 /*
11261  * generic initialization of ADC, input mixers and output mixers
11262  */
11263 static struct hda_verb alc262_volume_init_verbs[] = {
11264         /*
11265          * Unmute ADC0-2 and set the default input to mic-in
11266          */
11267         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11268         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11269         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11270         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11271         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11272         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11273
11274         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11275          * mixer widget
11276          * Note: PASD motherboards uses the Line In 2 as the input for
11277          * front panel mic (mic 2)
11278          */
11279         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11280         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11281         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11282         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11283         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11284         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11285
11286         /*
11287          * Set up output mixers (0x0c - 0x0f)
11288          */
11289         /* set vol=0 to output mixers */
11290         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11291         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11292         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11293
11294         /* set up input amps for analog loopback */
11295         /* Amp Indices: DAC = 0, mixer = 1 */
11296         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11297         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11298         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11299         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11300         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11301         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11302
11303         /* FIXME: use matrix-type input source selection */
11304         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11305         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11306         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11307         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11308         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11309         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11310         /* Input mixer2 */
11311         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11312         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11313         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11314         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11315         /* Input mixer3 */
11316         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11317         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11318         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11319         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11320
11321         { }
11322 };
11323
11324 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11325         /*
11326          * Unmute ADC0-2 and set the default input to mic-in
11327          */
11328         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11329         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11330         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11331         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11332         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11333         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11334
11335         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11336          * mixer widget
11337          * Note: PASD motherboards uses the Line In 2 as the input for
11338          * front panel mic (mic 2)
11339          */
11340         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11341         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11342         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11343         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11344         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11345         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11346         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11347         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11348
11349         /*
11350          * Set up output mixers (0x0c - 0x0e)
11351          */
11352         /* set vol=0 to output mixers */
11353         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11354         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11355         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11356
11357         /* set up input amps for analog loopback */
11358         /* Amp Indices: DAC = 0, mixer = 1 */
11359         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11360         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11361         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11362         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11363         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11364         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11365
11366         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11367         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11368         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11369
11370         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11371         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11372
11373         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11374         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11375
11376         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11377         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11378         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11379         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11380         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11381
11382         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11383         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11384         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11385         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11386         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11387         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11388
11389
11390         /* FIXME: use matrix-type input source selection */
11391         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11392         /* Input mixer1: only unmute Mic */
11393         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11394         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11395         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11396         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11397         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11398         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11399         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11400         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11401         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11402         /* Input mixer2 */
11403         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11404         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11405         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11406         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11407         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11408         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11409         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11410         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11411         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11412         /* Input mixer3 */
11413         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11414         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11415         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11416         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11417         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11418         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11419         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11420         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11421         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11422
11423         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11424
11425         { }
11426 };
11427
11428 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11429         /*
11430          * Unmute ADC0-2 and set the default input to mic-in
11431          */
11432         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11433         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11434         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11435         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11436         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11437         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11438
11439         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11440          * mixer widget
11441          * Note: PASD motherboards uses the Line In 2 as the input for front
11442          * panel mic (mic 2)
11443          */
11444         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11445         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11446         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11447         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11448         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11449         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11450         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11451         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11452         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11453         /*
11454          * Set up output mixers (0x0c - 0x0e)
11455          */
11456         /* set vol=0 to output mixers */
11457         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11458         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11459         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11460
11461         /* set up input amps for analog loopback */
11462         /* Amp Indices: DAC = 0, mixer = 1 */
11463         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11464         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11465         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11466         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11467         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11468         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11469
11470
11471         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11472         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11473         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11474         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11475         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11476         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11477         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11478
11479         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11480         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11481
11482         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11483         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11484
11485         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11486         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11487         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11488         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11489         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11490         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11491
11492         /* FIXME: use matrix-type input source selection */
11493         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11494         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11495         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11496         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11497         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11498         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11499         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11500         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11501         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11502         /* Input mixer2 */
11503         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11504         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11505         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11506         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11507         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11508         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11509         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11510         /* Input mixer3 */
11511         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11512         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11513         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11514         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11515         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11516         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11517         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11518
11519         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11520
11521         { }
11522 };
11523
11524 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11525
11526         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11527         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11528         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11529
11530         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11531         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11532         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11533         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11534
11535         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11536         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11537         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11538         {}
11539 };
11540
11541
11542 #ifdef CONFIG_SND_HDA_POWER_SAVE
11543 #define alc262_loopbacks        alc880_loopbacks
11544 #endif
11545
11546 /* pcm configuration: identical with ALC880 */
11547 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11548 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11549 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11550 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11551
11552 /*
11553  * BIOS auto configuration
11554  */
11555 static int alc262_parse_auto_config(struct hda_codec *codec)
11556 {
11557         struct alc_spec *spec = codec->spec;
11558         int err;
11559         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11560
11561         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11562                                            alc262_ignore);
11563         if (err < 0)
11564                 return err;
11565         if (!spec->autocfg.line_outs) {
11566                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11567                         spec->multiout.max_channels = 2;
11568                         spec->no_analog = 1;
11569                         goto dig_only;
11570                 }
11571                 return 0; /* can't find valid BIOS pin config */
11572         }
11573         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11574         if (err < 0)
11575                 return err;
11576         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11577         if (err < 0)
11578                 return err;
11579
11580         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11581
11582  dig_only:
11583         if (spec->autocfg.dig_outs) {
11584                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11585                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11586         }
11587         if (spec->autocfg.dig_in_pin)
11588                 spec->dig_in_nid = ALC262_DIGIN_NID;
11589
11590         if (spec->kctls.list)
11591                 add_mixer(spec, spec->kctls.list);
11592
11593         add_verb(spec, alc262_volume_init_verbs);
11594         spec->num_mux_defs = 1;
11595         spec->input_mux = &spec->private_imux[0];
11596
11597         err = alc_auto_add_mic_boost(codec);
11598         if (err < 0)
11599                 return err;
11600
11601         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11602
11603         return 1;
11604 }
11605
11606 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11607 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11608 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11609 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11610
11611
11612 /* init callback for auto-configuration model -- overriding the default init */
11613 static void alc262_auto_init(struct hda_codec *codec)
11614 {
11615         struct alc_spec *spec = codec->spec;
11616         alc262_auto_init_multi_out(codec);
11617         alc262_auto_init_hp_out(codec);
11618         alc262_auto_init_analog_input(codec);
11619         alc262_auto_init_input_src(codec);
11620         if (spec->unsol_event)
11621                 alc_inithook(codec);
11622 }
11623
11624 /*
11625  * configuration and preset
11626  */
11627 static const char *alc262_models[ALC262_MODEL_LAST] = {
11628         [ALC262_BASIC]          = "basic",
11629         [ALC262_HIPPO]          = "hippo",
11630         [ALC262_HIPPO_1]        = "hippo_1",
11631         [ALC262_FUJITSU]        = "fujitsu",
11632         [ALC262_HP_BPC]         = "hp-bpc",
11633         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11634         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11635         [ALC262_HP_RP5700]      = "hp-rp5700",
11636         [ALC262_BENQ_ED8]       = "benq",
11637         [ALC262_BENQ_T31]       = "benq-t31",
11638         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11639         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11640         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11641         [ALC262_ULTRA]          = "ultra",
11642         [ALC262_LENOVO_3000]    = "lenovo-3000",
11643         [ALC262_NEC]            = "nec",
11644         [ALC262_TYAN]           = "tyan",
11645         [ALC262_AUTO]           = "auto",
11646 };
11647
11648 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11649         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11650         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11651         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11652                            ALC262_HP_BPC),
11653         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11654                            ALC262_HP_BPC),
11655         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11656                            ALC262_HP_BPC),
11657         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11658         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11659         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11660         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11661         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11662         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11663         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11664         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11665         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11666         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11667         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11668         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11669                       ALC262_HP_TC_T5735),
11670         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11671         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11672         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11673         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11674         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11675         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11676         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11677         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11678 #if 0 /* disable the quirk since model=auto works better in recent versions */
11679         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11680                            ALC262_SONY_ASSAMD),
11681 #endif
11682         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11683                       ALC262_TOSHIBA_RX1),
11684         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11685         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11686         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11687         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11688         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11689                            ALC262_ULTRA),
11690         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11691         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11692         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11693         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11694         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11695         {}
11696 };
11697
11698 static struct alc_config_preset alc262_presets[] = {
11699         [ALC262_BASIC] = {
11700                 .mixers = { alc262_base_mixer },
11701                 .init_verbs = { alc262_init_verbs },
11702                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11703                 .dac_nids = alc262_dac_nids,
11704                 .hp_nid = 0x03,
11705                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11706                 .channel_mode = alc262_modes,
11707                 .input_mux = &alc262_capture_source,
11708         },
11709         [ALC262_HIPPO] = {
11710                 .mixers = { alc262_hippo_mixer },
11711                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11712                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11713                 .dac_nids = alc262_dac_nids,
11714                 .hp_nid = 0x03,
11715                 .dig_out_nid = ALC262_DIGOUT_NID,
11716                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11717                 .channel_mode = alc262_modes,
11718                 .input_mux = &alc262_capture_source,
11719                 .unsol_event = alc262_hippo_unsol_event,
11720                 .setup = alc262_hippo_setup,
11721                 .init_hook = alc262_hippo_automute,
11722         },
11723         [ALC262_HIPPO_1] = {
11724                 .mixers = { alc262_hippo1_mixer },
11725                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11726                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11727                 .dac_nids = alc262_dac_nids,
11728                 .hp_nid = 0x02,
11729                 .dig_out_nid = ALC262_DIGOUT_NID,
11730                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11731                 .channel_mode = alc262_modes,
11732                 .input_mux = &alc262_capture_source,
11733                 .unsol_event = alc262_hippo_unsol_event,
11734                 .setup = alc262_hippo1_setup,
11735                 .init_hook = alc262_hippo_automute,
11736         },
11737         [ALC262_FUJITSU] = {
11738                 .mixers = { alc262_fujitsu_mixer },
11739                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11740                                 alc262_fujitsu_unsol_verbs },
11741                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11742                 .dac_nids = alc262_dac_nids,
11743                 .hp_nid = 0x03,
11744                 .dig_out_nid = ALC262_DIGOUT_NID,
11745                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11746                 .channel_mode = alc262_modes,
11747                 .input_mux = &alc262_fujitsu_capture_source,
11748                 .unsol_event = alc262_fujitsu_unsol_event,
11749                 .init_hook = alc262_fujitsu_init_hook,
11750         },
11751         [ALC262_HP_BPC] = {
11752                 .mixers = { alc262_HP_BPC_mixer },
11753                 .init_verbs = { alc262_HP_BPC_init_verbs },
11754                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11755                 .dac_nids = alc262_dac_nids,
11756                 .hp_nid = 0x03,
11757                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11758                 .channel_mode = alc262_modes,
11759                 .input_mux = &alc262_HP_capture_source,
11760                 .unsol_event = alc262_hp_bpc_unsol_event,
11761                 .init_hook = alc262_hp_bpc_automute,
11762         },
11763         [ALC262_HP_BPC_D7000_WF] = {
11764                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11765                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11766                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11767                 .dac_nids = alc262_dac_nids,
11768                 .hp_nid = 0x03,
11769                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11770                 .channel_mode = alc262_modes,
11771                 .input_mux = &alc262_HP_D7000_capture_source,
11772                 .unsol_event = alc262_hp_wildwest_unsol_event,
11773                 .init_hook = alc262_hp_wildwest_automute,
11774         },
11775         [ALC262_HP_BPC_D7000_WL] = {
11776                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11777                             alc262_HP_BPC_WildWest_option_mixer },
11778                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11779                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11780                 .dac_nids = alc262_dac_nids,
11781                 .hp_nid = 0x03,
11782                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11783                 .channel_mode = alc262_modes,
11784                 .input_mux = &alc262_HP_D7000_capture_source,
11785                 .unsol_event = alc262_hp_wildwest_unsol_event,
11786                 .init_hook = alc262_hp_wildwest_automute,
11787         },
11788         [ALC262_HP_TC_T5735] = {
11789                 .mixers = { alc262_hp_t5735_mixer },
11790                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11791                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11792                 .dac_nids = alc262_dac_nids,
11793                 .hp_nid = 0x03,
11794                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11795                 .channel_mode = alc262_modes,
11796                 .input_mux = &alc262_capture_source,
11797                 .unsol_event = alc_sku_unsol_event,
11798                 .setup = alc262_hp_t5735_setup,
11799                 .init_hook = alc_inithook,
11800         },
11801         [ALC262_HP_RP5700] = {
11802                 .mixers = { alc262_hp_rp5700_mixer },
11803                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11804                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11805                 .dac_nids = alc262_dac_nids,
11806                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11807                 .channel_mode = alc262_modes,
11808                 .input_mux = &alc262_hp_rp5700_capture_source,
11809         },
11810         [ALC262_BENQ_ED8] = {
11811                 .mixers = { alc262_base_mixer },
11812                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11813                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11814                 .dac_nids = alc262_dac_nids,
11815                 .hp_nid = 0x03,
11816                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11817                 .channel_mode = alc262_modes,
11818                 .input_mux = &alc262_capture_source,
11819         },
11820         [ALC262_SONY_ASSAMD] = {
11821                 .mixers = { alc262_sony_mixer },
11822                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11823                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11824                 .dac_nids = alc262_dac_nids,
11825                 .hp_nid = 0x02,
11826                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11827                 .channel_mode = alc262_modes,
11828                 .input_mux = &alc262_capture_source,
11829                 .unsol_event = alc262_hippo_unsol_event,
11830                 .setup = alc262_hippo_setup,
11831                 .init_hook = alc262_hippo_automute,
11832         },
11833         [ALC262_BENQ_T31] = {
11834                 .mixers = { alc262_benq_t31_mixer },
11835                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
11836                                 alc_hp15_unsol_verbs },
11837                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11838                 .dac_nids = alc262_dac_nids,
11839                 .hp_nid = 0x03,
11840                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11841                 .channel_mode = alc262_modes,
11842                 .input_mux = &alc262_capture_source,
11843                 .unsol_event = alc262_hippo_unsol_event,
11844                 .setup = alc262_hippo_setup,
11845                 .init_hook = alc262_hippo_automute,
11846         },
11847         [ALC262_ULTRA] = {
11848                 .mixers = { alc262_ultra_mixer },
11849                 .cap_mixer = alc262_ultra_capture_mixer,
11850                 .init_verbs = { alc262_ultra_verbs },
11851                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11852                 .dac_nids = alc262_dac_nids,
11853                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11854                 .channel_mode = alc262_modes,
11855                 .input_mux = &alc262_ultra_capture_source,
11856                 .adc_nids = alc262_adc_nids, /* ADC0 */
11857                 .capsrc_nids = alc262_capsrc_nids,
11858                 .num_adc_nids = 1, /* single ADC */
11859                 .unsol_event = alc262_ultra_unsol_event,
11860                 .init_hook = alc262_ultra_automute,
11861         },
11862         [ALC262_LENOVO_3000] = {
11863                 .mixers = { alc262_lenovo_3000_mixer },
11864                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11865                                 alc262_lenovo_3000_unsol_verbs,
11866                                 alc262_lenovo_3000_init_verbs },
11867                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11868                 .dac_nids = alc262_dac_nids,
11869                 .hp_nid = 0x03,
11870                 .dig_out_nid = ALC262_DIGOUT_NID,
11871                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11872                 .channel_mode = alc262_modes,
11873                 .input_mux = &alc262_fujitsu_capture_source,
11874                 .unsol_event = alc262_lenovo_3000_unsol_event,
11875         },
11876         [ALC262_NEC] = {
11877                 .mixers = { alc262_nec_mixer },
11878                 .init_verbs = { alc262_nec_verbs },
11879                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11880                 .dac_nids = alc262_dac_nids,
11881                 .hp_nid = 0x03,
11882                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11883                 .channel_mode = alc262_modes,
11884                 .input_mux = &alc262_capture_source,
11885         },
11886         [ALC262_TOSHIBA_S06] = {
11887                 .mixers = { alc262_toshiba_s06_mixer },
11888                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11889                                                         alc262_eapd_verbs },
11890                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11891                 .capsrc_nids = alc262_dmic_capsrc_nids,
11892                 .dac_nids = alc262_dac_nids,
11893                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11894                 .num_adc_nids = 1, /* single ADC */
11895                 .dig_out_nid = ALC262_DIGOUT_NID,
11896                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11897                 .channel_mode = alc262_modes,
11898                 .unsol_event = alc_sku_unsol_event,
11899                 .setup = alc262_toshiba_s06_setup,
11900                 .init_hook = alc_inithook,
11901         },
11902         [ALC262_TOSHIBA_RX1] = {
11903                 .mixers = { alc262_toshiba_rx1_mixer },
11904                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11905                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11906                 .dac_nids = alc262_dac_nids,
11907                 .hp_nid = 0x03,
11908                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11909                 .channel_mode = alc262_modes,
11910                 .input_mux = &alc262_capture_source,
11911                 .unsol_event = alc262_hippo_unsol_event,
11912                 .setup = alc262_hippo_setup,
11913                 .init_hook = alc262_hippo_automute,
11914         },
11915         [ALC262_TYAN] = {
11916                 .mixers = { alc262_tyan_mixer },
11917                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11918                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11919                 .dac_nids = alc262_dac_nids,
11920                 .hp_nid = 0x02,
11921                 .dig_out_nid = ALC262_DIGOUT_NID,
11922                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11923                 .channel_mode = alc262_modes,
11924                 .input_mux = &alc262_capture_source,
11925                 .unsol_event = alc_automute_amp_unsol_event,
11926                 .setup = alc262_tyan_setup,
11927                 .init_hook = alc_automute_amp,
11928         },
11929 };
11930
11931 static int patch_alc262(struct hda_codec *codec)
11932 {
11933         struct alc_spec *spec;
11934         int board_config;
11935         int err;
11936
11937         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11938         if (spec == NULL)
11939                 return -ENOMEM;
11940
11941         codec->spec = spec;
11942 #if 0
11943         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11944          * under-run
11945          */
11946         {
11947         int tmp;
11948         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11949         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11950         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11951         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11952         }
11953 #endif
11954
11955         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11956
11957         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11958                                                   alc262_models,
11959                                                   alc262_cfg_tbl);
11960
11961         if (board_config < 0) {
11962                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11963                        codec->chip_name);
11964                 board_config = ALC262_AUTO;
11965         }
11966
11967         if (board_config == ALC262_AUTO) {
11968                 /* automatic parse from the BIOS config */
11969                 err = alc262_parse_auto_config(codec);
11970                 if (err < 0) {
11971                         alc_free(codec);
11972                         return err;
11973                 } else if (!err) {
11974                         printk(KERN_INFO
11975                                "hda_codec: Cannot set up configuration "
11976                                "from BIOS.  Using base mode...\n");
11977                         board_config = ALC262_BASIC;
11978                 }
11979         }
11980
11981         if (!spec->no_analog) {
11982                 err = snd_hda_attach_beep_device(codec, 0x1);
11983                 if (err < 0) {
11984                         alc_free(codec);
11985                         return err;
11986                 }
11987         }
11988
11989         if (board_config != ALC262_AUTO)
11990                 setup_preset(codec, &alc262_presets[board_config]);
11991
11992         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11993         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11994
11995         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11996         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11997
11998         if (!spec->adc_nids && spec->input_mux) {
11999                 int i;
12000                 /* check whether the digital-mic has to be supported */
12001                 for (i = 0; i < spec->input_mux->num_items; i++) {
12002                         if (spec->input_mux->items[i].index >= 9)
12003                                 break;
12004                 }
12005                 if (i < spec->input_mux->num_items) {
12006                         /* use only ADC0 */
12007                         spec->adc_nids = alc262_dmic_adc_nids;
12008                         spec->num_adc_nids = 1;
12009                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12010                 } else {
12011                         /* all analog inputs */
12012                         /* check whether NID 0x07 is valid */
12013                         unsigned int wcap = get_wcaps(codec, 0x07);
12014
12015                         /* get type */
12016                         wcap = get_wcaps_type(wcap);
12017                         if (wcap != AC_WID_AUD_IN) {
12018                                 spec->adc_nids = alc262_adc_nids_alt;
12019                                 spec->num_adc_nids =
12020                                         ARRAY_SIZE(alc262_adc_nids_alt);
12021                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12022                         } else {
12023                                 spec->adc_nids = alc262_adc_nids;
12024                                 spec->num_adc_nids =
12025                                         ARRAY_SIZE(alc262_adc_nids);
12026                                 spec->capsrc_nids = alc262_capsrc_nids;
12027                         }
12028                 }
12029         }
12030         if (!spec->cap_mixer && !spec->no_analog)
12031                 set_capture_mixer(codec);
12032         if (!spec->no_analog)
12033                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12034
12035         spec->vmaster_nid = 0x0c;
12036
12037         codec->patch_ops = alc_patch_ops;
12038         if (board_config == ALC262_AUTO)
12039                 spec->init_hook = alc262_auto_init;
12040 #ifdef CONFIG_SND_HDA_POWER_SAVE
12041         if (!spec->loopback.amplist)
12042                 spec->loopback.amplist = alc262_loopbacks;
12043 #endif
12044         codec->proc_widget_hook = print_realtek_coef;
12045
12046         return 0;
12047 }
12048
12049 /*
12050  *  ALC268 channel source setting (2 channel)
12051  */
12052 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12053 #define alc268_modes            alc260_modes
12054
12055 static hda_nid_t alc268_dac_nids[2] = {
12056         /* front, hp */
12057         0x02, 0x03
12058 };
12059
12060 static hda_nid_t alc268_adc_nids[2] = {
12061         /* ADC0-1 */
12062         0x08, 0x07
12063 };
12064
12065 static hda_nid_t alc268_adc_nids_alt[1] = {
12066         /* ADC0 */
12067         0x08
12068 };
12069
12070 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12071
12072 static struct snd_kcontrol_new alc268_base_mixer[] = {
12073         /* output mixer control */
12074         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12075         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12076         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12077         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12078         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12079         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12080         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12081         { }
12082 };
12083
12084 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12085         /* output mixer control */
12086         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12087         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12088         ALC262_HIPPO_MASTER_SWITCH,
12089         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12090         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12091         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12092         { }
12093 };
12094
12095 /* bind Beep switches of both NID 0x0f and 0x10 */
12096 static struct hda_bind_ctls alc268_bind_beep_sw = {
12097         .ops = &snd_hda_bind_sw,
12098         .values = {
12099                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12100                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12101                 0
12102         },
12103 };
12104
12105 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12106         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12107         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12108         { }
12109 };
12110
12111 static struct hda_verb alc268_eapd_verbs[] = {
12112         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12113         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12114         { }
12115 };
12116
12117 /* Toshiba specific */
12118 static struct hda_verb alc268_toshiba_verbs[] = {
12119         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12120         { } /* end */
12121 };
12122
12123 /* Acer specific */
12124 /* bind volumes of both NID 0x02 and 0x03 */
12125 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12126         .ops = &snd_hda_bind_vol,
12127         .values = {
12128                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12129                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12130                 0
12131         },
12132 };
12133
12134 /* mute/unmute internal speaker according to the hp jack and mute state */
12135 static void alc268_acer_automute(struct hda_codec *codec, int force)
12136 {
12137         struct alc_spec *spec = codec->spec;
12138         unsigned int mute;
12139
12140         if (force || !spec->sense_updated) {
12141                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12142                 spec->sense_updated = 1;
12143         }
12144         if (spec->jack_present)
12145                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12146         else /* unmute internal speaker if necessary */
12147                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12148         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12149                                  HDA_AMP_MUTE, mute);
12150 }
12151
12152
12153 /* bind hp and internal speaker mute (with plug check) */
12154 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12155                                      struct snd_ctl_elem_value *ucontrol)
12156 {
12157         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12158         long *valp = ucontrol->value.integer.value;
12159         int change;
12160
12161         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12162         if (change)
12163                 alc268_acer_automute(codec, 0);
12164         return change;
12165 }
12166
12167 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12168         /* output mixer control */
12169         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12170         {
12171                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12172                 .name = "Master Playback Switch",
12173                 .info = snd_hda_mixer_amp_switch_info,
12174                 .get = snd_hda_mixer_amp_switch_get,
12175                 .put = alc268_acer_master_sw_put,
12176                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12177         },
12178         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12179         { }
12180 };
12181
12182 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12183         /* output mixer control */
12184         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12185         {
12186                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12187                 .name = "Master Playback Switch",
12188                 .info = snd_hda_mixer_amp_switch_info,
12189                 .get = snd_hda_mixer_amp_switch_get,
12190                 .put = alc268_acer_master_sw_put,
12191                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12192         },
12193         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12194         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12195         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12196         { }
12197 };
12198
12199 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12200         /* output mixer control */
12201         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12202         {
12203                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12204                 .name = "Master Playback Switch",
12205                 .info = snd_hda_mixer_amp_switch_info,
12206                 .get = snd_hda_mixer_amp_switch_get,
12207                 .put = alc268_acer_master_sw_put,
12208                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12209         },
12210         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12211         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12212         { }
12213 };
12214
12215 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12216         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12217         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12218         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12219         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12220         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12221         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12222         { }
12223 };
12224
12225 static struct hda_verb alc268_acer_verbs[] = {
12226         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12227         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12228         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12229         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12230         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12231         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12232         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12233         { }
12234 };
12235
12236 /* unsolicited event for HP jack sensing */
12237 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12238 #define alc268_toshiba_setup            alc262_hippo_setup
12239 #define alc268_toshiba_automute         alc262_hippo_automute
12240
12241 static void alc268_acer_unsol_event(struct hda_codec *codec,
12242                                        unsigned int res)
12243 {
12244         if ((res >> 26) != ALC880_HP_EVENT)
12245                 return;
12246         alc268_acer_automute(codec, 1);
12247 }
12248
12249 static void alc268_acer_init_hook(struct hda_codec *codec)
12250 {
12251         alc268_acer_automute(codec, 1);
12252 }
12253
12254 /* toggle speaker-output according to the hp-jack state */
12255 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12256 {
12257         unsigned int present;
12258         unsigned char bits;
12259
12260         present = snd_hda_jack_detect(codec, 0x15);
12261         bits = present ? AMP_IN_MUTE(0) : 0;
12262         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12263                                 AMP_IN_MUTE(0), bits);
12264         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12265                                 AMP_IN_MUTE(0), bits);
12266 }
12267
12268 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12269                                     unsigned int res)
12270 {
12271         switch (res >> 26) {
12272         case ALC880_HP_EVENT:
12273                 alc268_aspire_one_speaker_automute(codec);
12274                 break;
12275         case ALC880_MIC_EVENT:
12276                 alc_mic_automute(codec);
12277                 break;
12278         }
12279 }
12280
12281 static void alc268_acer_lc_setup(struct hda_codec *codec)
12282 {
12283         struct alc_spec *spec = codec->spec;
12284         spec->ext_mic.pin = 0x18;
12285         spec->ext_mic.mux_idx = 0;
12286         spec->int_mic.pin = 0x12;
12287         spec->int_mic.mux_idx = 6;
12288         spec->auto_mic = 1;
12289 }
12290
12291 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12292 {
12293         alc268_aspire_one_speaker_automute(codec);
12294         alc_mic_automute(codec);
12295 }
12296
12297 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12298         /* output mixer control */
12299         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12300         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12301         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12302         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12303         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12304         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12305         { }
12306 };
12307
12308 static struct hda_verb alc268_dell_verbs[] = {
12309         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12310         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12311         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12312         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12313         { }
12314 };
12315
12316 /* mute/unmute internal speaker according to the hp jack and mute state */
12317 static void alc268_dell_setup(struct hda_codec *codec)
12318 {
12319         struct alc_spec *spec = codec->spec;
12320
12321         spec->autocfg.hp_pins[0] = 0x15;
12322         spec->autocfg.speaker_pins[0] = 0x14;
12323         spec->ext_mic.pin = 0x18;
12324         spec->ext_mic.mux_idx = 0;
12325         spec->int_mic.pin = 0x19;
12326         spec->int_mic.mux_idx = 1;
12327         spec->auto_mic = 1;
12328 }
12329
12330 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12331         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12332         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12333         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12334         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12335         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12336         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12337         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12338         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12339         { }
12340 };
12341
12342 static struct hda_verb alc267_quanta_il1_verbs[] = {
12343         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12344         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12345         { }
12346 };
12347
12348 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12349 {
12350         struct alc_spec *spec = codec->spec;
12351         spec->autocfg.hp_pins[0] = 0x15;
12352         spec->autocfg.speaker_pins[0] = 0x14;
12353         spec->ext_mic.pin = 0x18;
12354         spec->ext_mic.mux_idx = 0;
12355         spec->int_mic.pin = 0x19;
12356         spec->int_mic.mux_idx = 1;
12357         spec->auto_mic = 1;
12358 }
12359
12360 /*
12361  * generic initialization of ADC, input mixers and output mixers
12362  */
12363 static struct hda_verb alc268_base_init_verbs[] = {
12364         /* Unmute DAC0-1 and set vol = 0 */
12365         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12366         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12367
12368         /*
12369          * Set up output mixers (0x0c - 0x0e)
12370          */
12371         /* set vol=0 to output mixers */
12372         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12373         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12374
12375         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12376         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12377
12378         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12379         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12380         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12381         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12382         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12383         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12384         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12385         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12386
12387         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12388         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12389         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12390         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12391         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12392
12393         /* set PCBEEP vol = 0, mute connections */
12394         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12395         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12396         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12397
12398         /* Unmute Selector 23h,24h and set the default input to mic-in */
12399
12400         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12401         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12402         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12403         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12404
12405         { }
12406 };
12407
12408 /*
12409  * generic initialization of ADC, input mixers and output mixers
12410  */
12411 static struct hda_verb alc268_volume_init_verbs[] = {
12412         /* set output DAC */
12413         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12414         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12415
12416         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12417         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12418         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12419         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12420         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12421
12422         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12423         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12424         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12425
12426         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12427         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12428
12429         /* set PCBEEP vol = 0, mute connections */
12430         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12431         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12432         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12433
12434         { }
12435 };
12436
12437 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12438         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12439         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12440         { } /* end */
12441 };
12442
12443 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12444         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12445         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12446         _DEFINE_CAPSRC(1),
12447         { } /* end */
12448 };
12449
12450 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12451         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12452         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12453         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12454         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12455         _DEFINE_CAPSRC(2),
12456         { } /* end */
12457 };
12458
12459 static struct hda_input_mux alc268_capture_source = {
12460         .num_items = 4,
12461         .items = {
12462                 { "Mic", 0x0 },
12463                 { "Front Mic", 0x1 },
12464                 { "Line", 0x2 },
12465                 { "CD", 0x3 },
12466         },
12467 };
12468
12469 static struct hda_input_mux alc268_acer_capture_source = {
12470         .num_items = 3,
12471         .items = {
12472                 { "Mic", 0x0 },
12473                 { "Internal Mic", 0x1 },
12474                 { "Line", 0x2 },
12475         },
12476 };
12477
12478 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12479         .num_items = 3,
12480         .items = {
12481                 { "Mic", 0x0 },
12482                 { "Internal Mic", 0x6 },
12483                 { "Line", 0x2 },
12484         },
12485 };
12486
12487 #ifdef CONFIG_SND_DEBUG
12488 static struct snd_kcontrol_new alc268_test_mixer[] = {
12489         /* Volume widgets */
12490         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12491         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12492         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12493         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12494         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12495         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12496         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12497         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12498         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12499         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12500         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12501         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12502         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12503         /* The below appears problematic on some hardwares */
12504         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12505         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12506         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12507         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12508         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12509
12510         /* Modes for retasking pin widgets */
12511         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12512         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12513         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12514         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12515
12516         /* Controls for GPIO pins, assuming they are configured as outputs */
12517         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12518         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12519         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12520         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12521
12522         /* Switches to allow the digital SPDIF output pin to be enabled.
12523          * The ALC268 does not have an SPDIF input.
12524          */
12525         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12526
12527         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12528          * this output to turn on an external amplifier.
12529          */
12530         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12531         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12532
12533         { } /* end */
12534 };
12535 #endif
12536
12537 /* create input playback/capture controls for the given pin */
12538 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12539                                     const char *ctlname, int idx)
12540 {
12541         hda_nid_t dac;
12542         int err;
12543
12544         switch (nid) {
12545         case 0x14:
12546         case 0x16:
12547                 dac = 0x02;
12548                 break;
12549         case 0x15:
12550         case 0x21:
12551                 dac = 0x03;
12552                 break;
12553         default:
12554                 return 0;
12555         }
12556         if (spec->multiout.dac_nids[0] != dac &&
12557             spec->multiout.dac_nids[1] != dac) {
12558                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12559                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12560                                                       HDA_OUTPUT));
12561                 if (err < 0)
12562                         return err;
12563                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12564         }
12565
12566         if (nid != 0x16)
12567                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12568                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12569         else /* mono */
12570                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12571                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12572         if (err < 0)
12573                 return err;
12574         return 0;
12575 }
12576
12577 /* add playback controls from the parsed DAC table */
12578 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12579                                              const struct auto_pin_cfg *cfg)
12580 {
12581         hda_nid_t nid;
12582         int err;
12583
12584         spec->multiout.dac_nids = spec->private_dac_nids;
12585
12586         nid = cfg->line_out_pins[0];
12587         if (nid) {
12588                 const char *name;
12589                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12590                         name = "Speaker";
12591                 else
12592                         name = "Front";
12593                 err = alc268_new_analog_output(spec, nid, name, 0);
12594                 if (err < 0)
12595                         return err;
12596         }
12597
12598         nid = cfg->speaker_pins[0];
12599         if (nid == 0x1d) {
12600                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12601                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12602                 if (err < 0)
12603                         return err;
12604         } else {
12605                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12606                 if (err < 0)
12607                         return err;
12608         }
12609         nid = cfg->hp_pins[0];
12610         if (nid) {
12611                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12612                 if (err < 0)
12613                         return err;
12614         }
12615
12616         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12617         if (nid == 0x16) {
12618                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12619                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12620                 if (err < 0)
12621                         return err;
12622         }
12623         return 0;
12624 }
12625
12626 /* create playback/capture controls for input pins */
12627 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12628                                                 const struct auto_pin_cfg *cfg)
12629 {
12630         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12631 }
12632
12633 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12634                                               hda_nid_t nid, int pin_type)
12635 {
12636         int idx;
12637
12638         alc_set_pin_output(codec, nid, pin_type);
12639         if (nid == 0x14 || nid == 0x16)
12640                 idx = 0;
12641         else
12642                 idx = 1;
12643         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12644 }
12645
12646 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12647 {
12648         struct alc_spec *spec = codec->spec;
12649         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12650         if (nid) {
12651                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12652                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12653         }
12654 }
12655
12656 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12657 {
12658         struct alc_spec *spec = codec->spec;
12659         hda_nid_t pin;
12660
12661         pin = spec->autocfg.hp_pins[0];
12662         if (pin)
12663                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12664         pin = spec->autocfg.speaker_pins[0];
12665         if (pin)
12666                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12667 }
12668
12669 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12670 {
12671         struct alc_spec *spec = codec->spec;
12672         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12673         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12674         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12675         unsigned int    dac_vol1, dac_vol2;
12676
12677         if (line_nid == 0x1d || speaker_nid == 0x1d) {
12678                 snd_hda_codec_write(codec, speaker_nid, 0,
12679                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12680                 /* mute mixer inputs from 0x1d */
12681                 snd_hda_codec_write(codec, 0x0f, 0,
12682                                     AC_VERB_SET_AMP_GAIN_MUTE,
12683                                     AMP_IN_UNMUTE(1));
12684                 snd_hda_codec_write(codec, 0x10, 0,
12685                                     AC_VERB_SET_AMP_GAIN_MUTE,
12686                                     AMP_IN_UNMUTE(1));
12687         } else {
12688                 /* unmute mixer inputs from 0x1d */
12689                 snd_hda_codec_write(codec, 0x0f, 0,
12690                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12691                 snd_hda_codec_write(codec, 0x10, 0,
12692                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12693         }
12694
12695         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12696         if (line_nid == 0x14)
12697                 dac_vol2 = AMP_OUT_ZERO;
12698         else if (line_nid == 0x15)
12699                 dac_vol1 = AMP_OUT_ZERO;
12700         if (hp_nid == 0x14)
12701                 dac_vol2 = AMP_OUT_ZERO;
12702         else if (hp_nid == 0x15)
12703                 dac_vol1 = AMP_OUT_ZERO;
12704         if (line_nid != 0x16 || hp_nid != 0x16 ||
12705             spec->autocfg.line_out_pins[1] != 0x16 ||
12706             spec->autocfg.line_out_pins[2] != 0x16)
12707                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12708
12709         snd_hda_codec_write(codec, 0x02, 0,
12710                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12711         snd_hda_codec_write(codec, 0x03, 0,
12712                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12713 }
12714
12715 /* pcm configuration: identical with ALC880 */
12716 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12717 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12718 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12719 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12720
12721 /*
12722  * BIOS auto configuration
12723  */
12724 static int alc268_parse_auto_config(struct hda_codec *codec)
12725 {
12726         struct alc_spec *spec = codec->spec;
12727         int err;
12728         static hda_nid_t alc268_ignore[] = { 0 };
12729
12730         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12731                                            alc268_ignore);
12732         if (err < 0)
12733                 return err;
12734         if (!spec->autocfg.line_outs) {
12735                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12736                         spec->multiout.max_channels = 2;
12737                         spec->no_analog = 1;
12738                         goto dig_only;
12739                 }
12740                 return 0; /* can't find valid BIOS pin config */
12741         }
12742         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12743         if (err < 0)
12744                 return err;
12745         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
12746         if (err < 0)
12747                 return err;
12748
12749         spec->multiout.max_channels = 2;
12750
12751  dig_only:
12752         /* digital only support output */
12753         if (spec->autocfg.dig_outs) {
12754                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12755                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12756         }
12757         if (spec->kctls.list)
12758                 add_mixer(spec, spec->kctls.list);
12759
12760         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12761                 add_mixer(spec, alc268_beep_mixer);
12762
12763         add_verb(spec, alc268_volume_init_verbs);
12764         spec->num_mux_defs = 2;
12765         spec->input_mux = &spec->private_imux[0];
12766
12767         err = alc_auto_add_mic_boost(codec);
12768         if (err < 0)
12769                 return err;
12770
12771         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12772
12773         return 1;
12774 }
12775
12776 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12777
12778 /* init callback for auto-configuration model -- overriding the default init */
12779 static void alc268_auto_init(struct hda_codec *codec)
12780 {
12781         struct alc_spec *spec = codec->spec;
12782         alc268_auto_init_multi_out(codec);
12783         alc268_auto_init_hp_out(codec);
12784         alc268_auto_init_mono_speaker_out(codec);
12785         alc268_auto_init_analog_input(codec);
12786         if (spec->unsol_event)
12787                 alc_inithook(codec);
12788 }
12789
12790 /*
12791  * configuration and preset
12792  */
12793 static const char *alc268_models[ALC268_MODEL_LAST] = {
12794         [ALC267_QUANTA_IL1]     = "quanta-il1",
12795         [ALC268_3ST]            = "3stack",
12796         [ALC268_TOSHIBA]        = "toshiba",
12797         [ALC268_ACER]           = "acer",
12798         [ALC268_ACER_DMIC]      = "acer-dmic",
12799         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12800         [ALC268_DELL]           = "dell",
12801         [ALC268_ZEPTO]          = "zepto",
12802 #ifdef CONFIG_SND_DEBUG
12803         [ALC268_TEST]           = "test",
12804 #endif
12805         [ALC268_AUTO]           = "auto",
12806 };
12807
12808 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12809         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12810         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12811         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12812         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12813         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12814         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12815                                                 ALC268_ACER_ASPIRE_ONE),
12816         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12817         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
12818                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
12819         /* almost compatible with toshiba but with optional digital outs;
12820          * auto-probing seems working fine
12821          */
12822         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12823                            ALC268_AUTO),
12824         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12825         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12826         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12827         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12828         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12829         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12830         {}
12831 };
12832
12833 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
12834 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
12835         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
12836         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
12837         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12838                            ALC268_TOSHIBA),
12839         {}
12840 };
12841
12842 static struct alc_config_preset alc268_presets[] = {
12843         [ALC267_QUANTA_IL1] = {
12844                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
12845                             alc268_capture_nosrc_mixer },
12846                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12847                                 alc267_quanta_il1_verbs },
12848                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12849                 .dac_nids = alc268_dac_nids,
12850                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12851                 .adc_nids = alc268_adc_nids_alt,
12852                 .hp_nid = 0x03,
12853                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12854                 .channel_mode = alc268_modes,
12855                 .unsol_event = alc_sku_unsol_event,
12856                 .setup = alc267_quanta_il1_setup,
12857                 .init_hook = alc_inithook,
12858         },
12859         [ALC268_3ST] = {
12860                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12861                             alc268_beep_mixer },
12862                 .init_verbs = { alc268_base_init_verbs },
12863                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12864                 .dac_nids = alc268_dac_nids,
12865                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12866                 .adc_nids = alc268_adc_nids_alt,
12867                 .capsrc_nids = alc268_capsrc_nids,
12868                 .hp_nid = 0x03,
12869                 .dig_out_nid = ALC268_DIGOUT_NID,
12870                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12871                 .channel_mode = alc268_modes,
12872                 .input_mux = &alc268_capture_source,
12873         },
12874         [ALC268_TOSHIBA] = {
12875                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12876                             alc268_beep_mixer },
12877                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12878                                 alc268_toshiba_verbs },
12879                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12880                 .dac_nids = alc268_dac_nids,
12881                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12882                 .adc_nids = alc268_adc_nids_alt,
12883                 .capsrc_nids = alc268_capsrc_nids,
12884                 .hp_nid = 0x03,
12885                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12886                 .channel_mode = alc268_modes,
12887                 .input_mux = &alc268_capture_source,
12888                 .unsol_event = alc268_toshiba_unsol_event,
12889                 .setup = alc268_toshiba_setup,
12890                 .init_hook = alc268_toshiba_automute,
12891         },
12892         [ALC268_ACER] = {
12893                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12894                             alc268_beep_mixer },
12895                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12896                                 alc268_acer_verbs },
12897                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12898                 .dac_nids = alc268_dac_nids,
12899                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12900                 .adc_nids = alc268_adc_nids_alt,
12901                 .capsrc_nids = alc268_capsrc_nids,
12902                 .hp_nid = 0x02,
12903                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12904                 .channel_mode = alc268_modes,
12905                 .input_mux = &alc268_acer_capture_source,
12906                 .unsol_event = alc268_acer_unsol_event,
12907                 .init_hook = alc268_acer_init_hook,
12908         },
12909         [ALC268_ACER_DMIC] = {
12910                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12911                             alc268_beep_mixer },
12912                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12913                                 alc268_acer_verbs },
12914                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12915                 .dac_nids = alc268_dac_nids,
12916                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12917                 .adc_nids = alc268_adc_nids_alt,
12918                 .capsrc_nids = alc268_capsrc_nids,
12919                 .hp_nid = 0x02,
12920                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12921                 .channel_mode = alc268_modes,
12922                 .input_mux = &alc268_acer_dmic_capture_source,
12923                 .unsol_event = alc268_acer_unsol_event,
12924                 .init_hook = alc268_acer_init_hook,
12925         },
12926         [ALC268_ACER_ASPIRE_ONE] = {
12927                 .mixers = { alc268_acer_aspire_one_mixer,
12928                             alc268_beep_mixer,
12929                             alc268_capture_nosrc_mixer },
12930                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12931                                 alc268_acer_aspire_one_verbs },
12932                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12933                 .dac_nids = alc268_dac_nids,
12934                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12935                 .adc_nids = alc268_adc_nids_alt,
12936                 .capsrc_nids = alc268_capsrc_nids,
12937                 .hp_nid = 0x03,
12938                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12939                 .channel_mode = alc268_modes,
12940                 .unsol_event = alc268_acer_lc_unsol_event,
12941                 .setup = alc268_acer_lc_setup,
12942                 .init_hook = alc268_acer_lc_init_hook,
12943         },
12944         [ALC268_DELL] = {
12945                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
12946                             alc268_capture_nosrc_mixer },
12947                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12948                                 alc268_dell_verbs },
12949                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12950                 .dac_nids = alc268_dac_nids,
12951                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12952                 .adc_nids = alc268_adc_nids_alt,
12953                 .capsrc_nids = alc268_capsrc_nids,
12954                 .hp_nid = 0x02,
12955                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12956                 .channel_mode = alc268_modes,
12957                 .unsol_event = alc_sku_unsol_event,
12958                 .setup = alc268_dell_setup,
12959                 .init_hook = alc_inithook,
12960         },
12961         [ALC268_ZEPTO] = {
12962                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12963                             alc268_beep_mixer },
12964                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12965                                 alc268_toshiba_verbs },
12966                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12967                 .dac_nids = alc268_dac_nids,
12968                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12969                 .adc_nids = alc268_adc_nids_alt,
12970                 .capsrc_nids = alc268_capsrc_nids,
12971                 .hp_nid = 0x03,
12972                 .dig_out_nid = ALC268_DIGOUT_NID,
12973                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12974                 .channel_mode = alc268_modes,
12975                 .input_mux = &alc268_capture_source,
12976                 .setup = alc268_toshiba_setup,
12977                 .init_hook = alc268_toshiba_automute,
12978         },
12979 #ifdef CONFIG_SND_DEBUG
12980         [ALC268_TEST] = {
12981                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12982                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12983                                 alc268_volume_init_verbs },
12984                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12985                 .dac_nids = alc268_dac_nids,
12986                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12987                 .adc_nids = alc268_adc_nids_alt,
12988                 .capsrc_nids = alc268_capsrc_nids,
12989                 .hp_nid = 0x03,
12990                 .dig_out_nid = ALC268_DIGOUT_NID,
12991                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12992                 .channel_mode = alc268_modes,
12993                 .input_mux = &alc268_capture_source,
12994         },
12995 #endif
12996 };
12997
12998 static int patch_alc268(struct hda_codec *codec)
12999 {
13000         struct alc_spec *spec;
13001         int board_config;
13002         int i, has_beep, err;
13003
13004         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13005         if (spec == NULL)
13006                 return -ENOMEM;
13007
13008         codec->spec = spec;
13009
13010         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13011                                                   alc268_models,
13012                                                   alc268_cfg_tbl);
13013
13014         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13015                 board_config = snd_hda_check_board_codec_sid_config(codec,
13016                         ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13017
13018         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13019                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13020                        codec->chip_name);
13021                 board_config = ALC268_AUTO;
13022         }
13023
13024         if (board_config == ALC268_AUTO) {
13025                 /* automatic parse from the BIOS config */
13026                 err = alc268_parse_auto_config(codec);
13027                 if (err < 0) {
13028                         alc_free(codec);
13029                         return err;
13030                 } else if (!err) {
13031                         printk(KERN_INFO
13032                                "hda_codec: Cannot set up configuration "
13033                                "from BIOS.  Using base mode...\n");
13034                         board_config = ALC268_3ST;
13035                 }
13036         }
13037
13038         if (board_config != ALC268_AUTO)
13039                 setup_preset(codec, &alc268_presets[board_config]);
13040
13041         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13042         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13043         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13044
13045         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13046
13047         has_beep = 0;
13048         for (i = 0; i < spec->num_mixers; i++) {
13049                 if (spec->mixers[i] == alc268_beep_mixer) {
13050                         has_beep = 1;
13051                         break;
13052                 }
13053         }
13054
13055         if (has_beep) {
13056                 err = snd_hda_attach_beep_device(codec, 0x1);
13057                 if (err < 0) {
13058                         alc_free(codec);
13059                         return err;
13060                 }
13061                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13062                         /* override the amp caps for beep generator */
13063                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13064                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13065                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13066                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13067                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13068         }
13069
13070         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13071                 /* check whether NID 0x07 is valid */
13072                 unsigned int wcap = get_wcaps(codec, 0x07);
13073                 int i;
13074
13075                 spec->capsrc_nids = alc268_capsrc_nids;
13076                 /* get type */
13077                 wcap = get_wcaps_type(wcap);
13078                 if (spec->auto_mic ||
13079                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13080                         spec->adc_nids = alc268_adc_nids_alt;
13081                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13082                         if (spec->auto_mic)
13083                                 fixup_automic_adc(codec);
13084                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13085                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13086                         else
13087                                 add_mixer(spec, alc268_capture_alt_mixer);
13088                 } else {
13089                         spec->adc_nids = alc268_adc_nids;
13090                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13091                         add_mixer(spec, alc268_capture_mixer);
13092                 }
13093                 /* set default input source */
13094                 for (i = 0; i < spec->num_adc_nids; i++)
13095                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13096                                 0, AC_VERB_SET_CONNECT_SEL,
13097                                 i < spec->num_mux_defs ?
13098                                 spec->input_mux[i].items[0].index :
13099                                 spec->input_mux->items[0].index);
13100         }
13101
13102         spec->vmaster_nid = 0x02;
13103
13104         codec->patch_ops = alc_patch_ops;
13105         if (board_config == ALC268_AUTO)
13106                 spec->init_hook = alc268_auto_init;
13107
13108         codec->proc_widget_hook = print_realtek_coef;
13109
13110         return 0;
13111 }
13112
13113 /*
13114  *  ALC269 channel source setting (2 channel)
13115  */
13116 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13117
13118 #define alc269_dac_nids         alc260_dac_nids
13119
13120 static hda_nid_t alc269_adc_nids[1] = {
13121         /* ADC1 */
13122         0x08,
13123 };
13124
13125 static hda_nid_t alc269_capsrc_nids[1] = {
13126         0x23,
13127 };
13128
13129 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
13130  *       not a mux!
13131  */
13132
13133 #define alc269_modes            alc260_modes
13134 #define alc269_capture_source   alc880_lg_lw_capture_source
13135
13136 static struct snd_kcontrol_new alc269_base_mixer[] = {
13137         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13138         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13139         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13140         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13141         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13142         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13143         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13144         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13145         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13146         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13147         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13148         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13149         { } /* end */
13150 };
13151
13152 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13153         /* output mixer control */
13154         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13155         {
13156                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13157                 .name = "Master Playback Switch",
13158                 .info = snd_hda_mixer_amp_switch_info,
13159                 .get = snd_hda_mixer_amp_switch_get,
13160                 .put = alc268_acer_master_sw_put,
13161                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13162         },
13163         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13164         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13165         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13166         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13167         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13168         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13169         { }
13170 };
13171
13172 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13173         /* output mixer control */
13174         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13175         {
13176                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13177                 .name = "Master Playback Switch",
13178                 .info = snd_hda_mixer_amp_switch_info,
13179                 .get = snd_hda_mixer_amp_switch_get,
13180                 .put = alc268_acer_master_sw_put,
13181                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13182         },
13183         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13184         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13185         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13186         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13187         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13188         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13189         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13190         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13191         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13192         { }
13193 };
13194
13195 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
13196         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13197         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13198         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13199         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13200         { } /* end */
13201 };
13202
13203 /* capture mixer elements */
13204 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
13205         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13206         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13207         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13208         { } /* end */
13209 };
13210
13211 /* FSC amilo */
13212 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
13213
13214 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13215         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13216         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13217         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13218         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13219         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13220         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13221         { }
13222 };
13223
13224 static struct hda_verb alc269_lifebook_verbs[] = {
13225         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13226         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13227         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13228         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13229         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13230         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13231         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13232         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13233         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13234         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13235         { }
13236 };
13237
13238 /* toggle speaker-output according to the hp-jack state */
13239 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13240 {
13241         unsigned int present;
13242         unsigned char bits;
13243
13244         present = snd_hda_jack_detect(codec, 0x15);
13245         bits = present ? AMP_IN_MUTE(0) : 0;
13246         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13247                         AMP_IN_MUTE(0), bits);
13248         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13249                         AMP_IN_MUTE(0), bits);
13250
13251         snd_hda_codec_write(codec, 0x20, 0,
13252                         AC_VERB_SET_COEF_INDEX, 0x0c);
13253         snd_hda_codec_write(codec, 0x20, 0,
13254                         AC_VERB_SET_PROC_COEF, 0x680);
13255
13256         snd_hda_codec_write(codec, 0x20, 0,
13257                         AC_VERB_SET_COEF_INDEX, 0x0c);
13258         snd_hda_codec_write(codec, 0x20, 0,
13259                         AC_VERB_SET_PROC_COEF, 0x480);
13260 }
13261
13262 /* toggle speaker-output according to the hp-jacks state */
13263 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13264 {
13265         unsigned int present;
13266         unsigned char bits;
13267
13268         /* Check laptop headphone socket */
13269         present = snd_hda_jack_detect(codec, 0x15);
13270
13271         /* Check port replicator headphone socket */
13272         present |= snd_hda_jack_detect(codec, 0x1a);
13273
13274         bits = present ? AMP_IN_MUTE(0) : 0;
13275         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13276                         AMP_IN_MUTE(0), bits);
13277         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13278                         AMP_IN_MUTE(0), bits);
13279
13280         snd_hda_codec_write(codec, 0x20, 0,
13281                         AC_VERB_SET_COEF_INDEX, 0x0c);
13282         snd_hda_codec_write(codec, 0x20, 0,
13283                         AC_VERB_SET_PROC_COEF, 0x680);
13284
13285         snd_hda_codec_write(codec, 0x20, 0,
13286                         AC_VERB_SET_COEF_INDEX, 0x0c);
13287         snd_hda_codec_write(codec, 0x20, 0,
13288                         AC_VERB_SET_PROC_COEF, 0x480);
13289 }
13290
13291 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13292 {
13293         unsigned int present_laptop;
13294         unsigned int present_dock;
13295
13296         present_laptop  = snd_hda_jack_detect(codec, 0x18);
13297         present_dock    = snd_hda_jack_detect(codec, 0x1b);
13298
13299         /* Laptop mic port overrides dock mic port, design decision */
13300         if (present_dock)
13301                 snd_hda_codec_write(codec, 0x23, 0,
13302                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13303         if (present_laptop)
13304                 snd_hda_codec_write(codec, 0x23, 0,
13305                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13306         if (!present_dock && !present_laptop)
13307                 snd_hda_codec_write(codec, 0x23, 0,
13308                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13309 }
13310
13311 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13312                                     unsigned int res)
13313 {
13314         switch (res >> 26) {
13315         case ALC880_HP_EVENT:
13316                 alc269_quanta_fl1_speaker_automute(codec);
13317                 break;
13318         case ALC880_MIC_EVENT:
13319                 alc_mic_automute(codec);
13320                 break;
13321         }
13322 }
13323
13324 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13325                                         unsigned int res)
13326 {
13327         if ((res >> 26) == ALC880_HP_EVENT)
13328                 alc269_lifebook_speaker_automute(codec);
13329         if ((res >> 26) == ALC880_MIC_EVENT)
13330                 alc269_lifebook_mic_autoswitch(codec);
13331 }
13332
13333 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13334 {
13335         struct alc_spec *spec = codec->spec;
13336         spec->ext_mic.pin = 0x18;
13337         spec->ext_mic.mux_idx = 0;
13338         spec->int_mic.pin = 0x19;
13339         spec->int_mic.mux_idx = 1;
13340         spec->auto_mic = 1;
13341 }
13342
13343 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13344 {
13345         alc269_quanta_fl1_speaker_automute(codec);
13346         alc_mic_automute(codec);
13347 }
13348
13349 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13350 {
13351         alc269_lifebook_speaker_automute(codec);
13352         alc269_lifebook_mic_autoswitch(codec);
13353 }
13354
13355 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
13356         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13357         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13358         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13359         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13360         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13361         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13362         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13363         {}
13364 };
13365
13366 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
13367         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13368         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13369         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13370         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13371         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13372         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13373         {}
13374 };
13375
13376 /* toggle speaker-output according to the hp-jack state */
13377 static void alc269_speaker_automute(struct hda_codec *codec)
13378 {
13379         struct alc_spec *spec = codec->spec;
13380         unsigned int nid = spec->autocfg.hp_pins[0];
13381         unsigned int present;
13382         unsigned char bits;
13383
13384         present = snd_hda_jack_detect(codec, nid);
13385         bits = present ? AMP_IN_MUTE(0) : 0;
13386         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13387                                 AMP_IN_MUTE(0), bits);
13388         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13389                                 AMP_IN_MUTE(0), bits);
13390 }
13391
13392 /* unsolicited event for HP jack sensing */
13393 static void alc269_eeepc_unsol_event(struct hda_codec *codec,
13394                                      unsigned int res)
13395 {
13396         switch (res >> 26) {
13397         case ALC880_HP_EVENT:
13398                 alc269_speaker_automute(codec);
13399                 break;
13400         case ALC880_MIC_EVENT:
13401                 alc_mic_automute(codec);
13402                 break;
13403         }
13404 }
13405
13406 static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
13407 {
13408         struct alc_spec *spec = codec->spec;
13409         spec->ext_mic.pin = 0x18;
13410         spec->ext_mic.mux_idx = 0;
13411         spec->int_mic.pin = 0x12;
13412         spec->int_mic.mux_idx = 5;
13413         spec->auto_mic = 1;
13414 }
13415
13416 static void alc269_eeepc_amic_setup(struct hda_codec *codec)
13417 {
13418         struct alc_spec *spec = codec->spec;
13419         spec->ext_mic.pin = 0x18;
13420         spec->ext_mic.mux_idx = 0;
13421         spec->int_mic.pin = 0x19;
13422         spec->int_mic.mux_idx = 1;
13423         spec->auto_mic = 1;
13424 }
13425
13426 static void alc269_eeepc_inithook(struct hda_codec *codec)
13427 {
13428         alc269_speaker_automute(codec);
13429         alc_mic_automute(codec);
13430 }
13431
13432 /*
13433  * generic initialization of ADC, input mixers and output mixers
13434  */
13435 static struct hda_verb alc269_init_verbs[] = {
13436         /*
13437          * Unmute ADC0 and set the default input to mic-in
13438          */
13439         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13440
13441         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
13442          * analog-loopback mixer widget
13443          * Note: PASD motherboards uses the Line In 2 as the input for
13444          * front panel mic (mic 2)
13445          */
13446         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13447         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13448         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13449         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13450         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13451         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13452
13453         /*
13454          * Set up output mixers (0x0c - 0x0e)
13455          */
13456         /* set vol=0 to output mixers */
13457         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13458         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13459
13460         /* set up input amps for analog loopback */
13461         /* Amp Indices: DAC = 0, mixer = 1 */
13462         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13463         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13464         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13465         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13466         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13467         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13468
13469         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13470         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13471         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13472         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13473         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13474         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13475         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13476
13477         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13478         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13479         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13480         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13481         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13482         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13483         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13484
13485         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13486         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
13487
13488         /* FIXME: use matrix-type input source selection */
13489         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13490         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13491         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13492         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13493         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13494         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13495
13496         /* set EAPD */
13497         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13498         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13499         { }
13500 };
13501
13502 #define alc269_auto_create_multi_out_ctls \
13503         alc268_auto_create_multi_out_ctls
13504 #define alc269_auto_create_input_ctls \
13505         alc268_auto_create_input_ctls
13506
13507 #ifdef CONFIG_SND_HDA_POWER_SAVE
13508 #define alc269_loopbacks        alc880_loopbacks
13509 #endif
13510
13511 /* pcm configuration: identical with ALC880 */
13512 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13513 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13514 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13515 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13516
13517 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13518         .substreams = 1,
13519         .channels_min = 2,
13520         .channels_max = 8,
13521         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13522         /* NID is set in alc_build_pcms */
13523         .ops = {
13524                 .open = alc880_playback_pcm_open,
13525                 .prepare = alc880_playback_pcm_prepare,
13526                 .cleanup = alc880_playback_pcm_cleanup
13527         },
13528 };
13529
13530 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13531         .substreams = 1,
13532         .channels_min = 2,
13533         .channels_max = 2,
13534         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13535         /* NID is set in alc_build_pcms */
13536 };
13537
13538 /*
13539  * BIOS auto configuration
13540  */
13541 static int alc269_parse_auto_config(struct hda_codec *codec)
13542 {
13543         struct alc_spec *spec = codec->spec;
13544         int err;
13545         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13546
13547         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13548                                            alc269_ignore);
13549         if (err < 0)
13550                 return err;
13551
13552         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13553         if (err < 0)
13554                 return err;
13555         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13556         if (err < 0)
13557                 return err;
13558
13559         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13560
13561         if (spec->autocfg.dig_outs)
13562                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13563
13564         if (spec->kctls.list)
13565                 add_mixer(spec, spec->kctls.list);
13566
13567         add_verb(spec, alc269_init_verbs);
13568         spec->num_mux_defs = 1;
13569         spec->input_mux = &spec->private_imux[0];
13570         /* set default input source */
13571         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13572                                   0, AC_VERB_SET_CONNECT_SEL,
13573                                   spec->input_mux->items[0].index);
13574
13575         err = alc_auto_add_mic_boost(codec);
13576         if (err < 0)
13577                 return err;
13578
13579         if (!spec->cap_mixer && !spec->no_analog)
13580                 set_capture_mixer(codec);
13581
13582         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13583
13584         return 1;
13585 }
13586
13587 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
13588 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
13589 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13590
13591
13592 /* init callback for auto-configuration model -- overriding the default init */
13593 static void alc269_auto_init(struct hda_codec *codec)
13594 {
13595         struct alc_spec *spec = codec->spec;
13596         alc269_auto_init_multi_out(codec);
13597         alc269_auto_init_hp_out(codec);
13598         alc269_auto_init_analog_input(codec);
13599         if (spec->unsol_event)
13600                 alc_inithook(codec);
13601 }
13602
13603 /*
13604  * configuration and preset
13605  */
13606 static const char *alc269_models[ALC269_MODEL_LAST] = {
13607         [ALC269_BASIC]                  = "basic",
13608         [ALC269_QUANTA_FL1]             = "quanta",
13609         [ALC269_ASUS_AMIC]              = "asus-amic",
13610         [ALC269_ASUS_DMIC]              = "asus-dmic",
13611         [ALC269_FUJITSU]                = "fujitsu",
13612         [ALC269_LIFEBOOK]               = "lifebook",
13613         [ALC269_AUTO]                   = "auto",
13614 };
13615
13616 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13617         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13618         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13619                       ALC269_ASUS_AMIC),
13620         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_ASUS_AMIC),
13621         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80JT", ALC269_ASUS_AMIC),
13622         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_ASUS_AMIC),
13623         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_ASUS_AMIC),
13624         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_ASUS_AMIC),
13625         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_ASUS_AMIC),
13626         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_ASUS_AMIC),
13627         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_ASUS_AMIC),
13628         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_ASUS_AMIC),
13629         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_ASUS_AMIC),
13630         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_ASUS_AMIC),
13631         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_ASUS_AMIC),
13632         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_ASUS_AMIC),
13633         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_ASUS_AMIC),
13634         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_ASUS_AMIC),
13635         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_ASUS_AMIC),
13636         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_ASUS_AMIC),
13637         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_ASUS_AMIC),
13638         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_ASUS_AMIC),
13639         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_ASUS_AMIC),
13640         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_AMIC),
13641         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_ASUS_AMIC),
13642         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_AMIC),
13643         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_DMIC),
13644         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_AMIC),
13645         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_AMIC),
13646         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_AMIC),
13647         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_AMIC),
13648         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13649                       ALC269_ASUS_DMIC),
13650         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13651                       ALC269_ASUS_DMIC),
13652         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_ASUS_DMIC),
13653         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_ASUS_DMIC),
13654         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13655         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13656         {}
13657 };
13658
13659 static struct alc_config_preset alc269_presets[] = {
13660         [ALC269_BASIC] = {
13661                 .mixers = { alc269_base_mixer },
13662                 .init_verbs = { alc269_init_verbs },
13663                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13664                 .dac_nids = alc269_dac_nids,
13665                 .hp_nid = 0x03,
13666                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13667                 .channel_mode = alc269_modes,
13668                 .input_mux = &alc269_capture_source,
13669         },
13670         [ALC269_QUANTA_FL1] = {
13671                 .mixers = { alc269_quanta_fl1_mixer },
13672                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13673                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13674                 .dac_nids = alc269_dac_nids,
13675                 .hp_nid = 0x03,
13676                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13677                 .channel_mode = alc269_modes,
13678                 .input_mux = &alc269_capture_source,
13679                 .unsol_event = alc269_quanta_fl1_unsol_event,
13680                 .setup = alc269_quanta_fl1_setup,
13681                 .init_hook = alc269_quanta_fl1_init_hook,
13682         },
13683         [ALC269_ASUS_AMIC] = {
13684                 .mixers = { alc269_eeepc_mixer },
13685                 .cap_mixer = alc269_epc_capture_mixer,
13686                 .init_verbs = { alc269_init_verbs,
13687                                 alc269_eeepc_amic_init_verbs },
13688                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13689                 .dac_nids = alc269_dac_nids,
13690                 .hp_nid = 0x03,
13691                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13692                 .channel_mode = alc269_modes,
13693                 .unsol_event = alc269_eeepc_unsol_event,
13694                 .setup = alc269_eeepc_amic_setup,
13695                 .init_hook = alc269_eeepc_inithook,
13696         },
13697         [ALC269_ASUS_DMIC] = {
13698                 .mixers = { alc269_eeepc_mixer },
13699                 .cap_mixer = alc269_epc_capture_mixer,
13700                 .init_verbs = { alc269_init_verbs,
13701                                 alc269_eeepc_dmic_init_verbs },
13702                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13703                 .dac_nids = alc269_dac_nids,
13704                 .hp_nid = 0x03,
13705                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13706                 .channel_mode = alc269_modes,
13707                 .unsol_event = alc269_eeepc_unsol_event,
13708                 .setup = alc269_eeepc_dmic_setup,
13709                 .init_hook = alc269_eeepc_inithook,
13710         },
13711         [ALC269_FUJITSU] = {
13712                 .mixers = { alc269_fujitsu_mixer },
13713                 .cap_mixer = alc269_epc_capture_mixer,
13714                 .init_verbs = { alc269_init_verbs,
13715                                 alc269_eeepc_dmic_init_verbs },
13716                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13717                 .dac_nids = alc269_dac_nids,
13718                 .hp_nid = 0x03,
13719                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13720                 .channel_mode = alc269_modes,
13721                 .unsol_event = alc269_eeepc_unsol_event,
13722                 .setup = alc269_eeepc_dmic_setup,
13723                 .init_hook = alc269_eeepc_inithook,
13724         },
13725         [ALC269_LIFEBOOK] = {
13726                 .mixers = { alc269_lifebook_mixer },
13727                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13728                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13729                 .dac_nids = alc269_dac_nids,
13730                 .hp_nid = 0x03,
13731                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13732                 .channel_mode = alc269_modes,
13733                 .input_mux = &alc269_capture_source,
13734                 .unsol_event = alc269_lifebook_unsol_event,
13735                 .init_hook = alc269_lifebook_init_hook,
13736         },
13737 };
13738
13739 static int patch_alc269(struct hda_codec *codec)
13740 {
13741         struct alc_spec *spec;
13742         int board_config;
13743         int err;
13744
13745         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13746         if (spec == NULL)
13747                 return -ENOMEM;
13748
13749         codec->spec = spec;
13750
13751         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13752
13753         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
13754                 kfree(codec->chip_name);
13755                 codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
13756                 if (!codec->chip_name) {
13757                         alc_free(codec);
13758                         return -ENOMEM;
13759                 }
13760         }
13761
13762         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13763                                                   alc269_models,
13764                                                   alc269_cfg_tbl);
13765
13766         if (board_config < 0) {
13767                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13768                        codec->chip_name);
13769                 board_config = ALC269_AUTO;
13770         }
13771
13772         if (board_config == ALC269_AUTO) {
13773                 /* automatic parse from the BIOS config */
13774                 err = alc269_parse_auto_config(codec);
13775                 if (err < 0) {
13776                         alc_free(codec);
13777                         return err;
13778                 } else if (!err) {
13779                         printk(KERN_INFO
13780                                "hda_codec: Cannot set up configuration "
13781                                "from BIOS.  Using base mode...\n");
13782                         board_config = ALC269_BASIC;
13783                 }
13784         }
13785
13786         err = snd_hda_attach_beep_device(codec, 0x1);
13787         if (err < 0) {
13788                 alc_free(codec);
13789                 return err;
13790         }
13791
13792         if (board_config != ALC269_AUTO)
13793                 setup_preset(codec, &alc269_presets[board_config]);
13794
13795         if (codec->subsystem_id == 0x17aa3bf8) {
13796                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13797                  * fix the sample rate of analog I/O to 44.1kHz
13798                  */
13799                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13800                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13801         } else {
13802                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13803                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13804         }
13805         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13806         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13807
13808         spec->adc_nids = alc269_adc_nids;
13809         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13810         spec->capsrc_nids = alc269_capsrc_nids;
13811         if (!spec->cap_mixer)
13812                 set_capture_mixer(codec);
13813         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13814
13815         spec->vmaster_nid = 0x02;
13816
13817         codec->patch_ops = alc_patch_ops;
13818         if (board_config == ALC269_AUTO)
13819                 spec->init_hook = alc269_auto_init;
13820 #ifdef CONFIG_SND_HDA_POWER_SAVE
13821         if (!spec->loopback.amplist)
13822                 spec->loopback.amplist = alc269_loopbacks;
13823 #endif
13824         codec->proc_widget_hook = print_realtek_coef;
13825
13826         return 0;
13827 }
13828
13829 /*
13830  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13831  */
13832
13833 /*
13834  * set the path ways for 2 channel output
13835  * need to set the codec line out and mic 1 pin widgets to inputs
13836  */
13837 static struct hda_verb alc861_threestack_ch2_init[] = {
13838         /* set pin widget 1Ah (line in) for input */
13839         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13840         /* set pin widget 18h (mic1/2) for input, for mic also enable
13841          * the vref
13842          */
13843         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13844
13845         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13846 #if 0
13847         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13848         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13849 #endif
13850         { } /* end */
13851 };
13852 /*
13853  * 6ch mode
13854  * need to set the codec line out and mic 1 pin widgets to outputs
13855  */
13856 static struct hda_verb alc861_threestack_ch6_init[] = {
13857         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13858         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13859         /* set pin widget 18h (mic1) for output (CLFE)*/
13860         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13861
13862         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13863         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13864
13865         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13866 #if 0
13867         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13868         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13869 #endif
13870         { } /* end */
13871 };
13872
13873 static struct hda_channel_mode alc861_threestack_modes[2] = {
13874         { 2, alc861_threestack_ch2_init },
13875         { 6, alc861_threestack_ch6_init },
13876 };
13877 /* Set mic1 as input and unmute the mixer */
13878 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13879         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13880         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13881         { } /* end */
13882 };
13883 /* Set mic1 as output and mute mixer */
13884 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13885         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13886         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13887         { } /* end */
13888 };
13889
13890 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13891         { 2, alc861_uniwill_m31_ch2_init },
13892         { 4, alc861_uniwill_m31_ch4_init },
13893 };
13894
13895 /* Set mic1 and line-in as input and unmute the mixer */
13896 static struct hda_verb alc861_asus_ch2_init[] = {
13897         /* set pin widget 1Ah (line in) for input */
13898         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13899         /* set pin widget 18h (mic1/2) for input, for mic also enable
13900          * the vref
13901          */
13902         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13903
13904         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13905 #if 0
13906         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13907         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13908 #endif
13909         { } /* end */
13910 };
13911 /* Set mic1 nad line-in as output and mute mixer */
13912 static struct hda_verb alc861_asus_ch6_init[] = {
13913         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13914         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13915         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13916         /* set pin widget 18h (mic1) for output (CLFE)*/
13917         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13918         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13919         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13920         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13921
13922         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13923 #if 0
13924         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13925         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13926 #endif
13927         { } /* end */
13928 };
13929
13930 static struct hda_channel_mode alc861_asus_modes[2] = {
13931         { 2, alc861_asus_ch2_init },
13932         { 6, alc861_asus_ch6_init },
13933 };
13934
13935 /* patch-ALC861 */
13936
13937 static struct snd_kcontrol_new alc861_base_mixer[] = {
13938         /* output mixer control */
13939         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13940         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13941         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13942         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13943         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13944
13945         /*Input mixer control */
13946         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13947            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13948         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13949         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13950         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13951         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13952         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13953         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13954         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13955         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13956
13957         { } /* end */
13958 };
13959
13960 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13961         /* output mixer control */
13962         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13963         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13964         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13965         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13966         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13967
13968         /* Input mixer control */
13969         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13970            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13971         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13972         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13973         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13974         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13975         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13976         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13977         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13978         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13979
13980         {
13981                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13982                 .name = "Channel Mode",
13983                 .info = alc_ch_mode_info,
13984                 .get = alc_ch_mode_get,
13985                 .put = alc_ch_mode_put,
13986                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13987         },
13988         { } /* end */
13989 };
13990
13991 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13992         /* output mixer control */
13993         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13994         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13995         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13996
13997         { } /* end */
13998 };
13999
14000 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
14001         /* output mixer control */
14002         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14003         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14004         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14005         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14006         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14007
14008         /* Input mixer control */
14009         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14010            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14011         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14012         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14013         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14014         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14015         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14016         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14017         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14018         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14019
14020         {
14021                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14022                 .name = "Channel Mode",
14023                 .info = alc_ch_mode_info,
14024                 .get = alc_ch_mode_get,
14025                 .put = alc_ch_mode_put,
14026                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
14027         },
14028         { } /* end */
14029 };
14030
14031 static struct snd_kcontrol_new alc861_asus_mixer[] = {
14032         /* output mixer control */
14033         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14034         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14035         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14036         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14037         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14038
14039         /* Input mixer control */
14040         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14041         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14042         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14043         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14044         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14045         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14046         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14047         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14048         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14049         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
14050
14051         {
14052                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14053                 .name = "Channel Mode",
14054                 .info = alc_ch_mode_info,
14055                 .get = alc_ch_mode_get,
14056                 .put = alc_ch_mode_put,
14057                 .private_value = ARRAY_SIZE(alc861_asus_modes),
14058         },
14059         { }
14060 };
14061
14062 /* additional mixer */
14063 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
14064         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14065         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14066         { }
14067 };
14068
14069 /*
14070  * generic initialization of ADC, input mixers and output mixers
14071  */
14072 static struct hda_verb alc861_base_init_verbs[] = {
14073         /*
14074          * Unmute ADC0 and set the default input to mic-in
14075          */
14076         /* port-A for surround (rear panel) */
14077         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14078         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14079         /* port-B for mic-in (rear panel) with vref */
14080         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14081         /* port-C for line-in (rear panel) */
14082         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14083         /* port-D for Front */
14084         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14085         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14086         /* port-E for HP out (front panel) */
14087         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14088         /* route front PCM to HP */
14089         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14090         /* port-F for mic-in (front panel) with vref */
14091         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14092         /* port-G for CLFE (rear panel) */
14093         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14094         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14095         /* port-H for side (rear panel) */
14096         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14097         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14098         /* CD-in */
14099         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14100         /* route front mic to ADC1*/
14101         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14102         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14103
14104         /* Unmute DAC0~3 & spdif out*/
14105         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14106         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14107         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14108         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14109         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14110
14111         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14112         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14113         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14114         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14115         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14116
14117         /* Unmute Stereo Mixer 15 */
14118         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14119         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14120         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14121         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14122
14123         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14124         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14125         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14126         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14127         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14128         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14129         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14130         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14131         /* hp used DAC 3 (Front) */
14132         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14133         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14134
14135         { }
14136 };
14137
14138 static struct hda_verb alc861_threestack_init_verbs[] = {
14139         /*
14140          * Unmute ADC0 and set the default input to mic-in
14141          */
14142         /* port-A for surround (rear panel) */
14143         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14144         /* port-B for mic-in (rear panel) with vref */
14145         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14146         /* port-C for line-in (rear panel) */
14147         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14148         /* port-D for Front */
14149         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14150         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14151         /* port-E for HP out (front panel) */
14152         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14153         /* route front PCM to HP */
14154         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14155         /* port-F for mic-in (front panel) with vref */
14156         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14157         /* port-G for CLFE (rear panel) */
14158         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14159         /* port-H for side (rear panel) */
14160         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14161         /* CD-in */
14162         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14163         /* route front mic to ADC1*/
14164         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14165         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14166         /* Unmute DAC0~3 & spdif out*/
14167         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14168         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14169         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14170         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14171         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14172
14173         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14174         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14175         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14176         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14177         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14178
14179         /* Unmute Stereo Mixer 15 */
14180         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14181         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14182         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14183         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14184
14185         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14186         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14187         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14188         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14189         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14190         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14191         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14192         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14193         /* hp used DAC 3 (Front) */
14194         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14195         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14196         { }
14197 };
14198
14199 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14200         /*
14201          * Unmute ADC0 and set the default input to mic-in
14202          */
14203         /* port-A for surround (rear panel) */
14204         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14205         /* port-B for mic-in (rear panel) with vref */
14206         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14207         /* port-C for line-in (rear panel) */
14208         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14209         /* port-D for Front */
14210         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14211         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14212         /* port-E for HP out (front panel) */
14213         /* this has to be set to VREF80 */
14214         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14215         /* route front PCM to HP */
14216         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14217         /* port-F for mic-in (front panel) with vref */
14218         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14219         /* port-G for CLFE (rear panel) */
14220         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14221         /* port-H for side (rear panel) */
14222         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14223         /* CD-in */
14224         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14225         /* route front mic to ADC1*/
14226         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14227         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14228         /* Unmute DAC0~3 & spdif out*/
14229         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14230         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14231         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14232         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14233         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14234
14235         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14236         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14237         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14238         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14239         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14240
14241         /* Unmute Stereo Mixer 15 */
14242         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14243         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14244         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14245         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14246
14247         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14248         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14249         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14250         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14251         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14252         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14253         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14254         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14255         /* hp used DAC 3 (Front) */
14256         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14257         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14258         { }
14259 };
14260
14261 static struct hda_verb alc861_asus_init_verbs[] = {
14262         /*
14263          * Unmute ADC0 and set the default input to mic-in
14264          */
14265         /* port-A for surround (rear panel)
14266          * according to codec#0 this is the HP jack
14267          */
14268         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14269         /* route front PCM to HP */
14270         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14271         /* port-B for mic-in (rear panel) with vref */
14272         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14273         /* port-C for line-in (rear panel) */
14274         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14275         /* port-D for Front */
14276         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14277         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14278         /* port-E for HP out (front panel) */
14279         /* this has to be set to VREF80 */
14280         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14281         /* route front PCM to HP */
14282         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14283         /* port-F for mic-in (front panel) with vref */
14284         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14285         /* port-G for CLFE (rear panel) */
14286         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14287         /* port-H for side (rear panel) */
14288         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14289         /* CD-in */
14290         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14291         /* route front mic to ADC1*/
14292         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14293         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14294         /* Unmute DAC0~3 & spdif out*/
14295         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14296         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14297         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14298         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14299         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14300         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14301         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14302         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14303         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14304         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14305
14306         /* Unmute Stereo Mixer 15 */
14307         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14308         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14309         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14310         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14311
14312         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14313         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14314         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14315         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14316         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14317         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14318         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14319         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14320         /* hp used DAC 3 (Front) */
14321         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14322         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14323         { }
14324 };
14325
14326 /* additional init verbs for ASUS laptops */
14327 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14328         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14329         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14330         { }
14331 };
14332
14333 /*
14334  * generic initialization of ADC, input mixers and output mixers
14335  */
14336 static struct hda_verb alc861_auto_init_verbs[] = {
14337         /*
14338          * Unmute ADC0 and set the default input to mic-in
14339          */
14340         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14341         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14342
14343         /* Unmute DAC0~3 & spdif out*/
14344         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14345         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14346         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14347         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14348         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14349
14350         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14351         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14352         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14353         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14354         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14355
14356         /* Unmute Stereo Mixer 15 */
14357         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14358         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14359         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14360         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14361
14362         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14363         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14364         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14365         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14366         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14367         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14368         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14369         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14370
14371         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14372         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14373         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14374         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14375         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14376         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14377         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14378         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14379
14380         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14381
14382         { }
14383 };
14384
14385 static struct hda_verb alc861_toshiba_init_verbs[] = {
14386         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14387
14388         { }
14389 };
14390
14391 /* toggle speaker-output according to the hp-jack state */
14392 static void alc861_toshiba_automute(struct hda_codec *codec)
14393 {
14394         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14395
14396         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14397                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14398         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14399                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14400 }
14401
14402 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14403                                        unsigned int res)
14404 {
14405         if ((res >> 26) == ALC880_HP_EVENT)
14406                 alc861_toshiba_automute(codec);
14407 }
14408
14409 /* pcm configuration: identical with ALC880 */
14410 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14411 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14412 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14413 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14414
14415
14416 #define ALC861_DIGOUT_NID       0x07
14417
14418 static struct hda_channel_mode alc861_8ch_modes[1] = {
14419         { 8, NULL }
14420 };
14421
14422 static hda_nid_t alc861_dac_nids[4] = {
14423         /* front, surround, clfe, side */
14424         0x03, 0x06, 0x05, 0x04
14425 };
14426
14427 static hda_nid_t alc660_dac_nids[3] = {
14428         /* front, clfe, surround */
14429         0x03, 0x05, 0x06
14430 };
14431
14432 static hda_nid_t alc861_adc_nids[1] = {
14433         /* ADC0-2 */
14434         0x08,
14435 };
14436
14437 static struct hda_input_mux alc861_capture_source = {
14438         .num_items = 5,
14439         .items = {
14440                 { "Mic", 0x0 },
14441                 { "Front Mic", 0x3 },
14442                 { "Line", 0x1 },
14443                 { "CD", 0x4 },
14444                 { "Mixer", 0x5 },
14445         },
14446 };
14447
14448 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14449 {
14450         struct alc_spec *spec = codec->spec;
14451         hda_nid_t mix, srcs[5];
14452         int i, j, num;
14453
14454         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14455                 return 0;
14456         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14457         if (num < 0)
14458                 return 0;
14459         for (i = 0; i < num; i++) {
14460                 unsigned int type;
14461                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14462                 if (type != AC_WID_AUD_OUT)
14463                         continue;
14464                 for (j = 0; j < spec->multiout.num_dacs; j++)
14465                         if (spec->multiout.dac_nids[j] == srcs[i])
14466                                 break;
14467                 if (j >= spec->multiout.num_dacs)
14468                         return srcs[i];
14469         }
14470         return 0;
14471 }
14472
14473 /* fill in the dac_nids table from the parsed pin configuration */
14474 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14475                                      const struct auto_pin_cfg *cfg)
14476 {
14477         struct alc_spec *spec = codec->spec;
14478         int i;
14479         hda_nid_t nid, dac;
14480
14481         spec->multiout.dac_nids = spec->private_dac_nids;
14482         for (i = 0; i < cfg->line_outs; i++) {
14483                 nid = cfg->line_out_pins[i];
14484                 dac = alc861_look_for_dac(codec, nid);
14485                 if (!dac)
14486                         continue;
14487                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14488         }
14489         return 0;
14490 }
14491
14492 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14493                                 hda_nid_t nid, unsigned int chs)
14494 {
14495         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14496                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14497 }
14498
14499 /* add playback controls from the parsed DAC table */
14500 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14501                                              const struct auto_pin_cfg *cfg)
14502 {
14503         struct alc_spec *spec = codec->spec;
14504         static const char *chname[4] = {
14505                 "Front", "Surround", NULL /*CLFE*/, "Side"
14506         };
14507         hda_nid_t nid;
14508         int i, err;
14509
14510         if (cfg->line_outs == 1) {
14511                 const char *pfx = NULL;
14512                 if (!cfg->hp_outs)
14513                         pfx = "Master";
14514                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14515                         pfx = "Speaker";
14516                 if (pfx) {
14517                         nid = spec->multiout.dac_nids[0];
14518                         return alc861_create_out_sw(codec, pfx, nid, 3);
14519                 }
14520         }
14521
14522         for (i = 0; i < cfg->line_outs; i++) {
14523                 nid = spec->multiout.dac_nids[i];
14524                 if (!nid)
14525                         continue;
14526                 if (i == 2) {
14527                         /* Center/LFE */
14528                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14529                         if (err < 0)
14530                                 return err;
14531                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14532                         if (err < 0)
14533                                 return err;
14534                 } else {
14535                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14536                         if (err < 0)
14537                                 return err;
14538                 }
14539         }
14540         return 0;
14541 }
14542
14543 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14544 {
14545         struct alc_spec *spec = codec->spec;
14546         int err;
14547         hda_nid_t nid;
14548
14549         if (!pin)
14550                 return 0;
14551
14552         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14553                 nid = alc861_look_for_dac(codec, pin);
14554                 if (nid) {
14555                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14556                         if (err < 0)
14557                                 return err;
14558                         spec->multiout.hp_nid = nid;
14559                 }
14560         }
14561         return 0;
14562 }
14563
14564 /* create playback/capture controls for input pins */
14565 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14566                                                 const struct auto_pin_cfg *cfg)
14567 {
14568         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14569 }
14570
14571 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14572                                               hda_nid_t nid,
14573                                               int pin_type, hda_nid_t dac)
14574 {
14575         hda_nid_t mix, srcs[5];
14576         int i, num;
14577
14578         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14579                             pin_type);
14580         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14581                             AMP_OUT_UNMUTE);
14582         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14583                 return;
14584         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14585         if (num < 0)
14586                 return;
14587         for (i = 0; i < num; i++) {
14588                 unsigned int mute;
14589                 if (srcs[i] == dac || srcs[i] == 0x15)
14590                         mute = AMP_IN_UNMUTE(i);
14591                 else
14592                         mute = AMP_IN_MUTE(i);
14593                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14594                                     mute);
14595         }
14596 }
14597
14598 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14599 {
14600         struct alc_spec *spec = codec->spec;
14601         int i;
14602
14603         for (i = 0; i < spec->autocfg.line_outs; i++) {
14604                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14605                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14606                 if (nid)
14607                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14608                                                           spec->multiout.dac_nids[i]);
14609         }
14610 }
14611
14612 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14613 {
14614         struct alc_spec *spec = codec->spec;
14615
14616         if (spec->autocfg.hp_outs)
14617                 alc861_auto_set_output_and_unmute(codec,
14618                                                   spec->autocfg.hp_pins[0],
14619                                                   PIN_HP,
14620                                                   spec->multiout.hp_nid);
14621         if (spec->autocfg.speaker_outs)
14622                 alc861_auto_set_output_and_unmute(codec,
14623                                                   spec->autocfg.speaker_pins[0],
14624                                                   PIN_OUT,
14625                                                   spec->multiout.dac_nids[0]);
14626 }
14627
14628 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14629 {
14630         struct alc_spec *spec = codec->spec;
14631         int i;
14632
14633         for (i = 0; i < AUTO_PIN_LAST; i++) {
14634                 hda_nid_t nid = spec->autocfg.input_pins[i];
14635                 if (nid >= 0x0c && nid <= 0x11)
14636                         alc_set_input_pin(codec, nid, i);
14637         }
14638 }
14639
14640 /* parse the BIOS configuration and set up the alc_spec */
14641 /* return 1 if successful, 0 if the proper config is not found,
14642  * or a negative error code
14643  */
14644 static int alc861_parse_auto_config(struct hda_codec *codec)
14645 {
14646         struct alc_spec *spec = codec->spec;
14647         int err;
14648         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14649
14650         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14651                                            alc861_ignore);
14652         if (err < 0)
14653                 return err;
14654         if (!spec->autocfg.line_outs)
14655                 return 0; /* can't find valid BIOS pin config */
14656
14657         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14658         if (err < 0)
14659                 return err;
14660         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14661         if (err < 0)
14662                 return err;
14663         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14664         if (err < 0)
14665                 return err;
14666         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
14667         if (err < 0)
14668                 return err;
14669
14670         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14671
14672         if (spec->autocfg.dig_outs)
14673                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14674
14675         if (spec->kctls.list)
14676                 add_mixer(spec, spec->kctls.list);
14677
14678         add_verb(spec, alc861_auto_init_verbs);
14679
14680         spec->num_mux_defs = 1;
14681         spec->input_mux = &spec->private_imux[0];
14682
14683         spec->adc_nids = alc861_adc_nids;
14684         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14685         set_capture_mixer(codec);
14686
14687         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14688
14689         return 1;
14690 }
14691
14692 /* additional initialization for auto-configuration model */
14693 static void alc861_auto_init(struct hda_codec *codec)
14694 {
14695         struct alc_spec *spec = codec->spec;
14696         alc861_auto_init_multi_out(codec);
14697         alc861_auto_init_hp_out(codec);
14698         alc861_auto_init_analog_input(codec);
14699         if (spec->unsol_event)
14700                 alc_inithook(codec);
14701 }
14702
14703 #ifdef CONFIG_SND_HDA_POWER_SAVE
14704 static struct hda_amp_list alc861_loopbacks[] = {
14705         { 0x15, HDA_INPUT, 0 },
14706         { 0x15, HDA_INPUT, 1 },
14707         { 0x15, HDA_INPUT, 2 },
14708         { 0x15, HDA_INPUT, 3 },
14709         { } /* end */
14710 };
14711 #endif
14712
14713
14714 /*
14715  * configuration and preset
14716  */
14717 static const char *alc861_models[ALC861_MODEL_LAST] = {
14718         [ALC861_3ST]            = "3stack",
14719         [ALC660_3ST]            = "3stack-660",
14720         [ALC861_3ST_DIG]        = "3stack-dig",
14721         [ALC861_6ST_DIG]        = "6stack-dig",
14722         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14723         [ALC861_TOSHIBA]        = "toshiba",
14724         [ALC861_ASUS]           = "asus",
14725         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14726         [ALC861_AUTO]           = "auto",
14727 };
14728
14729 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14730         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14731         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14732         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14733         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14734         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14735         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14736         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14737         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14738          *        Any other models that need this preset?
14739          */
14740         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14741         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14742         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14743         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14744         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14745         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14746         /* FIXME: the below seems conflict */
14747         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14748         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14749         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14750         {}
14751 };
14752
14753 static struct alc_config_preset alc861_presets[] = {
14754         [ALC861_3ST] = {
14755                 .mixers = { alc861_3ST_mixer },
14756                 .init_verbs = { alc861_threestack_init_verbs },
14757                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14758                 .dac_nids = alc861_dac_nids,
14759                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14760                 .channel_mode = alc861_threestack_modes,
14761                 .need_dac_fix = 1,
14762                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14763                 .adc_nids = alc861_adc_nids,
14764                 .input_mux = &alc861_capture_source,
14765         },
14766         [ALC861_3ST_DIG] = {
14767                 .mixers = { alc861_base_mixer },
14768                 .init_verbs = { alc861_threestack_init_verbs },
14769                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14770                 .dac_nids = alc861_dac_nids,
14771                 .dig_out_nid = ALC861_DIGOUT_NID,
14772                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14773                 .channel_mode = alc861_threestack_modes,
14774                 .need_dac_fix = 1,
14775                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14776                 .adc_nids = alc861_adc_nids,
14777                 .input_mux = &alc861_capture_source,
14778         },
14779         [ALC861_6ST_DIG] = {
14780                 .mixers = { alc861_base_mixer },
14781                 .init_verbs = { alc861_base_init_verbs },
14782                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14783                 .dac_nids = alc861_dac_nids,
14784                 .dig_out_nid = ALC861_DIGOUT_NID,
14785                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14786                 .channel_mode = alc861_8ch_modes,
14787                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14788                 .adc_nids = alc861_adc_nids,
14789                 .input_mux = &alc861_capture_source,
14790         },
14791         [ALC660_3ST] = {
14792                 .mixers = { alc861_3ST_mixer },
14793                 .init_verbs = { alc861_threestack_init_verbs },
14794                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14795                 .dac_nids = alc660_dac_nids,
14796                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14797                 .channel_mode = alc861_threestack_modes,
14798                 .need_dac_fix = 1,
14799                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14800                 .adc_nids = alc861_adc_nids,
14801                 .input_mux = &alc861_capture_source,
14802         },
14803         [ALC861_UNIWILL_M31] = {
14804                 .mixers = { alc861_uniwill_m31_mixer },
14805                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14806                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14807                 .dac_nids = alc861_dac_nids,
14808                 .dig_out_nid = ALC861_DIGOUT_NID,
14809                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14810                 .channel_mode = alc861_uniwill_m31_modes,
14811                 .need_dac_fix = 1,
14812                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14813                 .adc_nids = alc861_adc_nids,
14814                 .input_mux = &alc861_capture_source,
14815         },
14816         [ALC861_TOSHIBA] = {
14817                 .mixers = { alc861_toshiba_mixer },
14818                 .init_verbs = { alc861_base_init_verbs,
14819                                 alc861_toshiba_init_verbs },
14820                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14821                 .dac_nids = alc861_dac_nids,
14822                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14823                 .channel_mode = alc883_3ST_2ch_modes,
14824                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14825                 .adc_nids = alc861_adc_nids,
14826                 .input_mux = &alc861_capture_source,
14827                 .unsol_event = alc861_toshiba_unsol_event,
14828                 .init_hook = alc861_toshiba_automute,
14829         },
14830         [ALC861_ASUS] = {
14831                 .mixers = { alc861_asus_mixer },
14832                 .init_verbs = { alc861_asus_init_verbs },
14833                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14834                 .dac_nids = alc861_dac_nids,
14835                 .dig_out_nid = ALC861_DIGOUT_NID,
14836                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14837                 .channel_mode = alc861_asus_modes,
14838                 .need_dac_fix = 1,
14839                 .hp_nid = 0x06,
14840                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14841                 .adc_nids = alc861_adc_nids,
14842                 .input_mux = &alc861_capture_source,
14843         },
14844         [ALC861_ASUS_LAPTOP] = {
14845                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14846                 .init_verbs = { alc861_asus_init_verbs,
14847                                 alc861_asus_laptop_init_verbs },
14848                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14849                 .dac_nids = alc861_dac_nids,
14850                 .dig_out_nid = ALC861_DIGOUT_NID,
14851                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14852                 .channel_mode = alc883_3ST_2ch_modes,
14853                 .need_dac_fix = 1,
14854                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14855                 .adc_nids = alc861_adc_nids,
14856                 .input_mux = &alc861_capture_source,
14857         },
14858 };
14859
14860 /* Pin config fixes */
14861 enum {
14862         PINFIX_FSC_AMILO_PI1505,
14863 };
14864
14865 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
14866         { 0x0b, 0x0221101f }, /* HP */
14867         { 0x0f, 0x90170310 }, /* speaker */
14868         { }
14869 };
14870
14871 static const struct alc_fixup alc861_fixups[] = {
14872         [PINFIX_FSC_AMILO_PI1505] = {
14873                 .pins = alc861_fsc_amilo_pi1505_pinfix
14874         },
14875 };
14876
14877 static struct snd_pci_quirk alc861_fixup_tbl[] = {
14878         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
14879         {}
14880 };
14881
14882 static int patch_alc861(struct hda_codec *codec)
14883 {
14884         struct alc_spec *spec;
14885         int board_config;
14886         int err;
14887
14888         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14889         if (spec == NULL)
14890                 return -ENOMEM;
14891
14892         codec->spec = spec;
14893
14894         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14895                                                   alc861_models,
14896                                                   alc861_cfg_tbl);
14897
14898         if (board_config < 0) {
14899                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14900                        codec->chip_name);
14901                 board_config = ALC861_AUTO;
14902         }
14903
14904         alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
14905
14906         if (board_config == ALC861_AUTO) {
14907                 /* automatic parse from the BIOS config */
14908                 err = alc861_parse_auto_config(codec);
14909                 if (err < 0) {
14910                         alc_free(codec);
14911                         return err;
14912                 } else if (!err) {
14913                         printk(KERN_INFO
14914                                "hda_codec: Cannot set up configuration "
14915                                "from BIOS.  Using base mode...\n");
14916                    board_config = ALC861_3ST_DIG;
14917                 }
14918         }
14919
14920         err = snd_hda_attach_beep_device(codec, 0x23);
14921         if (err < 0) {
14922                 alc_free(codec);
14923                 return err;
14924         }
14925
14926         if (board_config != ALC861_AUTO)
14927                 setup_preset(codec, &alc861_presets[board_config]);
14928
14929         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14930         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14931
14932         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14933         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14934
14935         if (!spec->cap_mixer)
14936                 set_capture_mixer(codec);
14937         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14938
14939         spec->vmaster_nid = 0x03;
14940
14941         codec->patch_ops = alc_patch_ops;
14942         if (board_config == ALC861_AUTO)
14943                 spec->init_hook = alc861_auto_init;
14944 #ifdef CONFIG_SND_HDA_POWER_SAVE
14945         if (!spec->loopback.amplist)
14946                 spec->loopback.amplist = alc861_loopbacks;
14947 #endif
14948         codec->proc_widget_hook = print_realtek_coef;
14949
14950         return 0;
14951 }
14952
14953 /*
14954  * ALC861-VD support
14955  *
14956  * Based on ALC882
14957  *
14958  * In addition, an independent DAC
14959  */
14960 #define ALC861VD_DIGOUT_NID     0x06
14961
14962 static hda_nid_t alc861vd_dac_nids[4] = {
14963         /* front, surr, clfe, side surr */
14964         0x02, 0x03, 0x04, 0x05
14965 };
14966
14967 /* dac_nids for ALC660vd are in a different order - according to
14968  * Realtek's driver.
14969  * This should probably result in a different mixer for 6stack models
14970  * of ALC660vd codecs, but for now there is only 3stack mixer
14971  * - and it is the same as in 861vd.
14972  * adc_nids in ALC660vd are (is) the same as in 861vd
14973  */
14974 static hda_nid_t alc660vd_dac_nids[3] = {
14975         /* front, rear, clfe, rear_surr */
14976         0x02, 0x04, 0x03
14977 };
14978
14979 static hda_nid_t alc861vd_adc_nids[1] = {
14980         /* ADC0 */
14981         0x09,
14982 };
14983
14984 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14985
14986 /* input MUX */
14987 /* FIXME: should be a matrix-type input source selection */
14988 static struct hda_input_mux alc861vd_capture_source = {
14989         .num_items = 4,
14990         .items = {
14991                 { "Mic", 0x0 },
14992                 { "Front Mic", 0x1 },
14993                 { "Line", 0x2 },
14994                 { "CD", 0x4 },
14995         },
14996 };
14997
14998 static struct hda_input_mux alc861vd_dallas_capture_source = {
14999         .num_items = 2,
15000         .items = {
15001                 { "Ext Mic", 0x0 },
15002                 { "Int Mic", 0x1 },
15003         },
15004 };
15005
15006 static struct hda_input_mux alc861vd_hp_capture_source = {
15007         .num_items = 2,
15008         .items = {
15009                 { "Front Mic", 0x0 },
15010                 { "ATAPI Mic", 0x1 },
15011         },
15012 };
15013
15014 /*
15015  * 2ch mode
15016  */
15017 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
15018         { 2, NULL }
15019 };
15020
15021 /*
15022  * 6ch mode
15023  */
15024 static struct hda_verb alc861vd_6stack_ch6_init[] = {
15025         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15026         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15027         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15028         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15029         { } /* end */
15030 };
15031
15032 /*
15033  * 8ch mode
15034  */
15035 static struct hda_verb alc861vd_6stack_ch8_init[] = {
15036         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15037         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15038         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15039         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15040         { } /* end */
15041 };
15042
15043 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
15044         { 6, alc861vd_6stack_ch6_init },
15045         { 8, alc861vd_6stack_ch8_init },
15046 };
15047
15048 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
15049         {
15050                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15051                 .name = "Channel Mode",
15052                 .info = alc_ch_mode_info,
15053                 .get = alc_ch_mode_get,
15054                 .put = alc_ch_mode_put,
15055         },
15056         { } /* end */
15057 };
15058
15059 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15060  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15061  */
15062 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
15063         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15064         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15065
15066         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15067         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
15068
15069         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
15070                                 HDA_OUTPUT),
15071         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
15072                                 HDA_OUTPUT),
15073         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
15074         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
15075
15076         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
15077         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
15078
15079         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15080
15081         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15082         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15083         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15084
15085         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15086         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15087         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15088
15089         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15090         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15091
15092         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15093         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15094
15095         { } /* end */
15096 };
15097
15098 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15099         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15100         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15101
15102         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15103
15104         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15105         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15106         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15107
15108         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15109         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15110         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15111
15112         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15113         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15114
15115         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15116         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15117
15118         { } /* end */
15119 };
15120
15121 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15122         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15123         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15124         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15125
15126         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15127
15128         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15130         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15131
15132         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15133         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15134         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15135
15136         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15137         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15138
15139         { } /* end */
15140 };
15141
15142 /* Pin assignment: Speaker=0x14, HP = 0x15,
15143  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15144  */
15145 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15146         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15147         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15148         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15149         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15150         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15151         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15152         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15153         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15154         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15155         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15156         { } /* end */
15157 };
15158
15159 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15160  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15161  */
15162 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15163         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15164         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15165         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15166         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15167         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15168         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15169         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15170         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15171
15172         { } /* end */
15173 };
15174
15175 /*
15176  * generic initialization of ADC, input mixers and output mixers
15177  */
15178 static struct hda_verb alc861vd_volume_init_verbs[] = {
15179         /*
15180          * Unmute ADC0 and set the default input to mic-in
15181          */
15182         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15183         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15184
15185         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15186          * the analog-loopback mixer widget
15187          */
15188         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15189         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15190         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15191         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15192         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15193         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15194
15195         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15196         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15197         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15198         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15199         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15200
15201         /*
15202          * Set up output mixers (0x02 - 0x05)
15203          */
15204         /* set vol=0 to output mixers */
15205         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15206         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15207         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15208         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15209
15210         /* set up input amps for analog loopback */
15211         /* Amp Indices: DAC = 0, mixer = 1 */
15212         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15213         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15214         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15215         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15216         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15217         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15218         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15219         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15220
15221         { }
15222 };
15223
15224 /*
15225  * 3-stack pin configuration:
15226  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15227  */
15228 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15229         /*
15230          * Set pin mode and muting
15231          */
15232         /* set front pin widgets 0x14 for output */
15233         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15234         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15235         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15236
15237         /* Mic (rear) pin: input vref at 80% */
15238         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15239         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15240         /* Front Mic pin: input vref at 80% */
15241         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15242         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15243         /* Line In pin: input */
15244         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15245         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15246         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15247         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15248         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15249         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15250         /* CD pin widget for input */
15251         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15252
15253         { }
15254 };
15255
15256 /*
15257  * 6-stack pin configuration:
15258  */
15259 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15260         /*
15261          * Set pin mode and muting
15262          */
15263         /* set front pin widgets 0x14 for output */
15264         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15265         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15266         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15267
15268         /* Rear Pin: output 1 (0x0d) */
15269         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15270         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15271         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15272         /* CLFE Pin: output 2 (0x0e) */
15273         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15274         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15275         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15276         /* Side Pin: output 3 (0x0f) */
15277         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15278         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15279         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15280
15281         /* Mic (rear) pin: input vref at 80% */
15282         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15283         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15284         /* Front Mic pin: input vref at 80% */
15285         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15286         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15287         /* Line In pin: input */
15288         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15289         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15290         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15291         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15292         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15293         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15294         /* CD pin widget for input */
15295         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15296
15297         { }
15298 };
15299
15300 static struct hda_verb alc861vd_eapd_verbs[] = {
15301         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15302         { }
15303 };
15304
15305 static struct hda_verb alc660vd_eapd_verbs[] = {
15306         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15307         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15308         { }
15309 };
15310
15311 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15312         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15313         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15314         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15315         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15316         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15317         {}
15318 };
15319
15320 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15321 {
15322         unsigned int present;
15323         unsigned char bits;
15324
15325         present = snd_hda_jack_detect(codec, 0x18);
15326         bits = present ? HDA_AMP_MUTE : 0;
15327
15328         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15329                                  HDA_AMP_MUTE, bits);
15330 }
15331
15332 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15333 {
15334         struct alc_spec *spec = codec->spec;
15335         spec->autocfg.hp_pins[0] = 0x1b;
15336         spec->autocfg.speaker_pins[0] = 0x14;
15337 }
15338
15339 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15340 {
15341         alc_automute_amp(codec);
15342         alc861vd_lenovo_mic_automute(codec);
15343 }
15344
15345 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15346                                         unsigned int res)
15347 {
15348         switch (res >> 26) {
15349         case ALC880_MIC_EVENT:
15350                 alc861vd_lenovo_mic_automute(codec);
15351                 break;
15352         default:
15353                 alc_automute_amp_unsol_event(codec, res);
15354                 break;
15355         }
15356 }
15357
15358 static struct hda_verb alc861vd_dallas_verbs[] = {
15359         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15360         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15361         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15362         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15363
15364         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15365         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15366         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15367         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15368         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15369         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15370         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15371         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15372
15373         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15374         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15375         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15376         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15377         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15378         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15379         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15380         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15381
15382         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15383         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15384         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15385         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15386         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15387         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15388         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15389         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15390
15391         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15392         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15393         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15394         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15395
15396         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15397         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15398         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15399
15400         { } /* end */
15401 };
15402
15403 /* toggle speaker-output according to the hp-jack state */
15404 static void alc861vd_dallas_setup(struct hda_codec *codec)
15405 {
15406         struct alc_spec *spec = codec->spec;
15407
15408         spec->autocfg.hp_pins[0] = 0x15;
15409         spec->autocfg.speaker_pins[0] = 0x14;
15410 }
15411
15412 #ifdef CONFIG_SND_HDA_POWER_SAVE
15413 #define alc861vd_loopbacks      alc880_loopbacks
15414 #endif
15415
15416 /* pcm configuration: identical with ALC880 */
15417 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15418 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15419 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15420 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15421
15422 /*
15423  * configuration and preset
15424  */
15425 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15426         [ALC660VD_3ST]          = "3stack-660",
15427         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15428         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15429         [ALC861VD_3ST]          = "3stack",
15430         [ALC861VD_3ST_DIG]      = "3stack-digout",
15431         [ALC861VD_6ST_DIG]      = "6stack-digout",
15432         [ALC861VD_LENOVO]       = "lenovo",
15433         [ALC861VD_DALLAS]       = "dallas",
15434         [ALC861VD_HP]           = "hp",
15435         [ALC861VD_AUTO]         = "auto",
15436 };
15437
15438 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15439         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15440         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15441         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15442         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15443         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15444         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15445         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15446         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15447         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15448         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15449         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15450         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15451         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15452         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15453         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15454         {}
15455 };
15456
15457 static struct alc_config_preset alc861vd_presets[] = {
15458         [ALC660VD_3ST] = {
15459                 .mixers = { alc861vd_3st_mixer },
15460                 .init_verbs = { alc861vd_volume_init_verbs,
15461                                  alc861vd_3stack_init_verbs },
15462                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15463                 .dac_nids = alc660vd_dac_nids,
15464                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15465                 .channel_mode = alc861vd_3stack_2ch_modes,
15466                 .input_mux = &alc861vd_capture_source,
15467         },
15468         [ALC660VD_3ST_DIG] = {
15469                 .mixers = { alc861vd_3st_mixer },
15470                 .init_verbs = { alc861vd_volume_init_verbs,
15471                                  alc861vd_3stack_init_verbs },
15472                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15473                 .dac_nids = alc660vd_dac_nids,
15474                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15475                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15476                 .channel_mode = alc861vd_3stack_2ch_modes,
15477                 .input_mux = &alc861vd_capture_source,
15478         },
15479         [ALC861VD_3ST] = {
15480                 .mixers = { alc861vd_3st_mixer },
15481                 .init_verbs = { alc861vd_volume_init_verbs,
15482                                  alc861vd_3stack_init_verbs },
15483                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15484                 .dac_nids = alc861vd_dac_nids,
15485                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15486                 .channel_mode = alc861vd_3stack_2ch_modes,
15487                 .input_mux = &alc861vd_capture_source,
15488         },
15489         [ALC861VD_3ST_DIG] = {
15490                 .mixers = { alc861vd_3st_mixer },
15491                 .init_verbs = { alc861vd_volume_init_verbs,
15492                                  alc861vd_3stack_init_verbs },
15493                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15494                 .dac_nids = alc861vd_dac_nids,
15495                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15496                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15497                 .channel_mode = alc861vd_3stack_2ch_modes,
15498                 .input_mux = &alc861vd_capture_source,
15499         },
15500         [ALC861VD_6ST_DIG] = {
15501                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15502                 .init_verbs = { alc861vd_volume_init_verbs,
15503                                 alc861vd_6stack_init_verbs },
15504                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15505                 .dac_nids = alc861vd_dac_nids,
15506                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15507                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15508                 .channel_mode = alc861vd_6stack_modes,
15509                 .input_mux = &alc861vd_capture_source,
15510         },
15511         [ALC861VD_LENOVO] = {
15512                 .mixers = { alc861vd_lenovo_mixer },
15513                 .init_verbs = { alc861vd_volume_init_verbs,
15514                                 alc861vd_3stack_init_verbs,
15515                                 alc861vd_eapd_verbs,
15516                                 alc861vd_lenovo_unsol_verbs },
15517                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15518                 .dac_nids = alc660vd_dac_nids,
15519                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15520                 .channel_mode = alc861vd_3stack_2ch_modes,
15521                 .input_mux = &alc861vd_capture_source,
15522                 .unsol_event = alc861vd_lenovo_unsol_event,
15523                 .setup = alc861vd_lenovo_setup,
15524                 .init_hook = alc861vd_lenovo_init_hook,
15525         },
15526         [ALC861VD_DALLAS] = {
15527                 .mixers = { alc861vd_dallas_mixer },
15528                 .init_verbs = { alc861vd_dallas_verbs },
15529                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15530                 .dac_nids = alc861vd_dac_nids,
15531                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15532                 .channel_mode = alc861vd_3stack_2ch_modes,
15533                 .input_mux = &alc861vd_dallas_capture_source,
15534                 .unsol_event = alc_automute_amp_unsol_event,
15535                 .setup = alc861vd_dallas_setup,
15536                 .init_hook = alc_automute_amp,
15537         },
15538         [ALC861VD_HP] = {
15539                 .mixers = { alc861vd_hp_mixer },
15540                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15541                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15542                 .dac_nids = alc861vd_dac_nids,
15543                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15544                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15545                 .channel_mode = alc861vd_3stack_2ch_modes,
15546                 .input_mux = &alc861vd_hp_capture_source,
15547                 .unsol_event = alc_automute_amp_unsol_event,
15548                 .setup = alc861vd_dallas_setup,
15549                 .init_hook = alc_automute_amp,
15550         },
15551         [ALC660VD_ASUS_V1S] = {
15552                 .mixers = { alc861vd_lenovo_mixer },
15553                 .init_verbs = { alc861vd_volume_init_verbs,
15554                                 alc861vd_3stack_init_verbs,
15555                                 alc861vd_eapd_verbs,
15556                                 alc861vd_lenovo_unsol_verbs },
15557                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15558                 .dac_nids = alc660vd_dac_nids,
15559                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15560                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15561                 .channel_mode = alc861vd_3stack_2ch_modes,
15562                 .input_mux = &alc861vd_capture_source,
15563                 .unsol_event = alc861vd_lenovo_unsol_event,
15564                 .setup = alc861vd_lenovo_setup,
15565                 .init_hook = alc861vd_lenovo_init_hook,
15566         },
15567 };
15568
15569 /*
15570  * BIOS auto configuration
15571  */
15572 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
15573                                                 const struct auto_pin_cfg *cfg)
15574 {
15575         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x22, 0);
15576 }
15577
15578
15579 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15580                                 hda_nid_t nid, int pin_type, int dac_idx)
15581 {
15582         alc_set_pin_output(codec, nid, pin_type);
15583 }
15584
15585 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15586 {
15587         struct alc_spec *spec = codec->spec;
15588         int i;
15589
15590         for (i = 0; i <= HDA_SIDE; i++) {
15591                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15592                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15593                 if (nid)
15594                         alc861vd_auto_set_output_and_unmute(codec, nid,
15595                                                             pin_type, i);
15596         }
15597 }
15598
15599
15600 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15601 {
15602         struct alc_spec *spec = codec->spec;
15603         hda_nid_t pin;
15604
15605         pin = spec->autocfg.hp_pins[0];
15606         if (pin) /* connect to front and use dac 0 */
15607                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15608         pin = spec->autocfg.speaker_pins[0];
15609         if (pin)
15610                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15611 }
15612
15613 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
15614
15615 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15616 {
15617         struct alc_spec *spec = codec->spec;
15618         int i;
15619
15620         for (i = 0; i < AUTO_PIN_LAST; i++) {
15621                 hda_nid_t nid = spec->autocfg.input_pins[i];
15622                 if (alc_is_input_pin(codec, nid)) {
15623                         alc_set_input_pin(codec, nid, i);
15624                         if (nid != ALC861VD_PIN_CD_NID &&
15625                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15626                                 snd_hda_codec_write(codec, nid, 0,
15627                                                 AC_VERB_SET_AMP_GAIN_MUTE,
15628                                                 AMP_OUT_MUTE);
15629                 }
15630         }
15631 }
15632
15633 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
15634
15635 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
15636 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
15637
15638 /* add playback controls from the parsed DAC table */
15639 /* Based on ALC880 version. But ALC861VD has separate,
15640  * different NIDs for mute/unmute switch and volume control */
15641 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15642                                              const struct auto_pin_cfg *cfg)
15643 {
15644         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15645         hda_nid_t nid_v, nid_s;
15646         int i, err;
15647
15648         for (i = 0; i < cfg->line_outs; i++) {
15649                 if (!spec->multiout.dac_nids[i])
15650                         continue;
15651                 nid_v = alc861vd_idx_to_mixer_vol(
15652                                 alc880_dac_to_idx(
15653                                         spec->multiout.dac_nids[i]));
15654                 nid_s = alc861vd_idx_to_mixer_switch(
15655                                 alc880_dac_to_idx(
15656                                         spec->multiout.dac_nids[i]));
15657
15658                 if (i == 2) {
15659                         /* Center/LFE */
15660                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15661                                               "Center",
15662                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15663                                                               HDA_OUTPUT));
15664                         if (err < 0)
15665                                 return err;
15666                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15667                                               "LFE",
15668                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15669                                                               HDA_OUTPUT));
15670                         if (err < 0)
15671                                 return err;
15672                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15673                                              "Center",
15674                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15675                                                               HDA_INPUT));
15676                         if (err < 0)
15677                                 return err;
15678                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15679                                              "LFE",
15680                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15681                                                               HDA_INPUT));
15682                         if (err < 0)
15683                                 return err;
15684                 } else {
15685                         const char *pfx;
15686                         if (cfg->line_outs == 1 &&
15687                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
15688                                 if (!cfg->hp_pins)
15689                                         pfx = "Speaker";
15690                                 else
15691                                         pfx = "PCM";
15692                         } else
15693                                 pfx = chname[i];
15694                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15695                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15696                                                               HDA_OUTPUT));
15697                         if (err < 0)
15698                                 return err;
15699                         if (cfg->line_outs == 1 &&
15700                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15701                                 pfx = "Speaker";
15702                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15703                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15704                                                               HDA_INPUT));
15705                         if (err < 0)
15706                                 return err;
15707                 }
15708         }
15709         return 0;
15710 }
15711
15712 /* add playback controls for speaker and HP outputs */
15713 /* Based on ALC880 version. But ALC861VD has separate,
15714  * different NIDs for mute/unmute switch and volume control */
15715 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15716                                         hda_nid_t pin, const char *pfx)
15717 {
15718         hda_nid_t nid_v, nid_s;
15719         int err;
15720
15721         if (!pin)
15722                 return 0;
15723
15724         if (alc880_is_fixed_pin(pin)) {
15725                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15726                 /* specify the DAC as the extra output */
15727                 if (!spec->multiout.hp_nid)
15728                         spec->multiout.hp_nid = nid_v;
15729                 else
15730                         spec->multiout.extra_out_nid[0] = nid_v;
15731                 /* control HP volume/switch on the output mixer amp */
15732                 nid_v = alc861vd_idx_to_mixer_vol(
15733                                 alc880_fixed_pin_idx(pin));
15734                 nid_s = alc861vd_idx_to_mixer_switch(
15735                                 alc880_fixed_pin_idx(pin));
15736
15737                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15738                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15739                 if (err < 0)
15740                         return err;
15741                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15742                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15743                 if (err < 0)
15744                         return err;
15745         } else if (alc880_is_multi_pin(pin)) {
15746                 /* set manual connection */
15747                 /* we have only a switch on HP-out PIN */
15748                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
15749                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15750                 if (err < 0)
15751                         return err;
15752         }
15753         return 0;
15754 }
15755
15756 /* parse the BIOS configuration and set up the alc_spec
15757  * return 1 if successful, 0 if the proper config is not found,
15758  * or a negative error code
15759  * Based on ALC880 version - had to change it to override
15760  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15761 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15762 {
15763         struct alc_spec *spec = codec->spec;
15764         int err;
15765         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15766
15767         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15768                                            alc861vd_ignore);
15769         if (err < 0)
15770                 return err;
15771         if (!spec->autocfg.line_outs)
15772                 return 0; /* can't find valid BIOS pin config */
15773
15774         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15775         if (err < 0)
15776                 return err;
15777         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15778         if (err < 0)
15779                 return err;
15780         err = alc861vd_auto_create_extra_out(spec,
15781                                              spec->autocfg.speaker_pins[0],
15782                                              "Speaker");
15783         if (err < 0)
15784                 return err;
15785         err = alc861vd_auto_create_extra_out(spec,
15786                                              spec->autocfg.hp_pins[0],
15787                                              "Headphone");
15788         if (err < 0)
15789                 return err;
15790         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
15791         if (err < 0)
15792                 return err;
15793
15794         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15795
15796         if (spec->autocfg.dig_outs)
15797                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15798
15799         if (spec->kctls.list)
15800                 add_mixer(spec, spec->kctls.list);
15801
15802         add_verb(spec, alc861vd_volume_init_verbs);
15803
15804         spec->num_mux_defs = 1;
15805         spec->input_mux = &spec->private_imux[0];
15806
15807         err = alc_auto_add_mic_boost(codec);
15808         if (err < 0)
15809                 return err;
15810
15811         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15812
15813         return 1;
15814 }
15815
15816 /* additional initialization for auto-configuration model */
15817 static void alc861vd_auto_init(struct hda_codec *codec)
15818 {
15819         struct alc_spec *spec = codec->spec;
15820         alc861vd_auto_init_multi_out(codec);
15821         alc861vd_auto_init_hp_out(codec);
15822         alc861vd_auto_init_analog_input(codec);
15823         alc861vd_auto_init_input_src(codec);
15824         if (spec->unsol_event)
15825                 alc_inithook(codec);
15826 }
15827
15828 enum {
15829         ALC660VD_FIX_ASUS_GPIO1
15830 };
15831
15832 /* reset GPIO1 */
15833 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
15834         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
15835         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
15836         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
15837         { }
15838 };
15839
15840 static const struct alc_fixup alc861vd_fixups[] = {
15841         [ALC660VD_FIX_ASUS_GPIO1] = {
15842                 .verbs = alc660vd_fix_asus_gpio1_verbs,
15843         },
15844 };
15845
15846 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
15847         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
15848         {}
15849 };
15850
15851 static int patch_alc861vd(struct hda_codec *codec)
15852 {
15853         struct alc_spec *spec;
15854         int err, board_config;
15855
15856         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15857         if (spec == NULL)
15858                 return -ENOMEM;
15859
15860         codec->spec = spec;
15861
15862         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15863                                                   alc861vd_models,
15864                                                   alc861vd_cfg_tbl);
15865
15866         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15867                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15868                        codec->chip_name);
15869                 board_config = ALC861VD_AUTO;
15870         }
15871
15872         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
15873
15874         if (board_config == ALC861VD_AUTO) {
15875                 /* automatic parse from the BIOS config */
15876                 err = alc861vd_parse_auto_config(codec);
15877                 if (err < 0) {
15878                         alc_free(codec);
15879                         return err;
15880                 } else if (!err) {
15881                         printk(KERN_INFO
15882                                "hda_codec: Cannot set up configuration "
15883                                "from BIOS.  Using base mode...\n");
15884                         board_config = ALC861VD_3ST;
15885                 }
15886         }
15887
15888         err = snd_hda_attach_beep_device(codec, 0x23);
15889         if (err < 0) {
15890                 alc_free(codec);
15891                 return err;
15892         }
15893
15894         if (board_config != ALC861VD_AUTO)
15895                 setup_preset(codec, &alc861vd_presets[board_config]);
15896
15897         if (codec->vendor_id == 0x10ec0660) {
15898                 /* always turn on EAPD */
15899                 add_verb(spec, alc660vd_eapd_verbs);
15900         }
15901
15902         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15903         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15904
15905         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15906         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15907
15908         if (!spec->adc_nids) {
15909                 spec->adc_nids = alc861vd_adc_nids;
15910                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15911         }
15912         if (!spec->capsrc_nids)
15913                 spec->capsrc_nids = alc861vd_capsrc_nids;
15914
15915         set_capture_mixer(codec);
15916         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15917
15918         spec->vmaster_nid = 0x02;
15919
15920         codec->patch_ops = alc_patch_ops;
15921
15922         if (board_config == ALC861VD_AUTO)
15923                 spec->init_hook = alc861vd_auto_init;
15924 #ifdef CONFIG_SND_HDA_POWER_SAVE
15925         if (!spec->loopback.amplist)
15926                 spec->loopback.amplist = alc861vd_loopbacks;
15927 #endif
15928         codec->proc_widget_hook = print_realtek_coef;
15929
15930         return 0;
15931 }
15932
15933 /*
15934  * ALC662 support
15935  *
15936  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15937  * configuration.  Each pin widget can choose any input DACs and a mixer.
15938  * Each ADC is connected from a mixer of all inputs.  This makes possible
15939  * 6-channel independent captures.
15940  *
15941  * In addition, an independent DAC for the multi-playback (not used in this
15942  * driver yet).
15943  */
15944 #define ALC662_DIGOUT_NID       0x06
15945 #define ALC662_DIGIN_NID        0x0a
15946
15947 static hda_nid_t alc662_dac_nids[4] = {
15948         /* front, rear, clfe, rear_surr */
15949         0x02, 0x03, 0x04
15950 };
15951
15952 static hda_nid_t alc272_dac_nids[2] = {
15953         0x02, 0x03
15954 };
15955
15956 static hda_nid_t alc662_adc_nids[2] = {
15957         /* ADC1-2 */
15958         0x09, 0x08
15959 };
15960
15961 static hda_nid_t alc272_adc_nids[1] = {
15962         /* ADC1-2 */
15963         0x08,
15964 };
15965
15966 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
15967 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15968
15969
15970 /* input MUX */
15971 /* FIXME: should be a matrix-type input source selection */
15972 static struct hda_input_mux alc662_capture_source = {
15973         .num_items = 4,
15974         .items = {
15975                 { "Mic", 0x0 },
15976                 { "Front Mic", 0x1 },
15977                 { "Line", 0x2 },
15978                 { "CD", 0x4 },
15979         },
15980 };
15981
15982 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15983         .num_items = 2,
15984         .items = {
15985                 { "Mic", 0x1 },
15986                 { "Line", 0x2 },
15987         },
15988 };
15989
15990 static struct hda_input_mux alc663_capture_source = {
15991         .num_items = 3,
15992         .items = {
15993                 { "Mic", 0x0 },
15994                 { "Front Mic", 0x1 },
15995                 { "Line", 0x2 },
15996         },
15997 };
15998
15999 #if 0 /* set to 1 for testing other input sources below */
16000 static struct hda_input_mux alc272_nc10_capture_source = {
16001         .num_items = 16,
16002         .items = {
16003                 { "Autoselect Mic", 0x0 },
16004                 { "Internal Mic", 0x1 },
16005                 { "In-0x02", 0x2 },
16006                 { "In-0x03", 0x3 },
16007                 { "In-0x04", 0x4 },
16008                 { "In-0x05", 0x5 },
16009                 { "In-0x06", 0x6 },
16010                 { "In-0x07", 0x7 },
16011                 { "In-0x08", 0x8 },
16012                 { "In-0x09", 0x9 },
16013                 { "In-0x0a", 0x0a },
16014                 { "In-0x0b", 0x0b },
16015                 { "In-0x0c", 0x0c },
16016                 { "In-0x0d", 0x0d },
16017                 { "In-0x0e", 0x0e },
16018                 { "In-0x0f", 0x0f },
16019         },
16020 };
16021 #endif
16022
16023 /*
16024  * 2ch mode
16025  */
16026 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
16027         { 2, NULL }
16028 };
16029
16030 /*
16031  * 2ch mode
16032  */
16033 static struct hda_verb alc662_3ST_ch2_init[] = {
16034         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
16035         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16036         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
16037         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16038         { } /* end */
16039 };
16040
16041 /*
16042  * 6ch mode
16043  */
16044 static struct hda_verb alc662_3ST_ch6_init[] = {
16045         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16046         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16047         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
16048         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16049         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16050         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
16051         { } /* end */
16052 };
16053
16054 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
16055         { 2, alc662_3ST_ch2_init },
16056         { 6, alc662_3ST_ch6_init },
16057 };
16058
16059 /*
16060  * 2ch mode
16061  */
16062 static struct hda_verb alc662_sixstack_ch6_init[] = {
16063         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16064         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16065         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16066         { } /* end */
16067 };
16068
16069 /*
16070  * 6ch mode
16071  */
16072 static struct hda_verb alc662_sixstack_ch8_init[] = {
16073         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16074         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16075         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16076         { } /* end */
16077 };
16078
16079 static struct hda_channel_mode alc662_5stack_modes[2] = {
16080         { 2, alc662_sixstack_ch6_init },
16081         { 6, alc662_sixstack_ch8_init },
16082 };
16083
16084 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16085  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16086  */
16087
16088 static struct snd_kcontrol_new alc662_base_mixer[] = {
16089         /* output mixer control */
16090         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16091         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16092         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16093         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16094         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16095         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16096         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16097         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16098         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16099
16100         /*Input mixer control */
16101         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16102         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16103         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16104         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16105         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16106         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16107         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16108         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16109         { } /* end */
16110 };
16111
16112 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16113         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16114         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16115         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16116         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16117         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16118         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16119         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16120         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16121         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16122         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16123         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16124         { } /* end */
16125 };
16126
16127 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16128         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16129         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16130         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16131         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16132         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16133         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16134         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16135         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16136         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16137         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16138         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16139         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16140         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16141         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16142         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16143         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16144         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16145         { } /* end */
16146 };
16147
16148 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16149         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16150         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16151         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16152         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16153         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16154         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16155         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16156         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16157         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16158         { } /* end */
16159 };
16160
16161 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16162         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16163         ALC262_HIPPO_MASTER_SWITCH,
16164
16165         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16166         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16167         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16168
16169         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16170         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16171         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16172         { } /* end */
16173 };
16174
16175 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16176         ALC262_HIPPO_MASTER_SWITCH,
16177         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16178         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16179         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16180         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16181         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16182         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16183         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16184         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16185         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16186         { } /* end */
16187 };
16188
16189 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16190         .ops = &snd_hda_bind_vol,
16191         .values = {
16192                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16193                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16194                 0
16195         },
16196 };
16197
16198 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16199         .ops = &snd_hda_bind_sw,
16200         .values = {
16201                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16202                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16203                 0
16204         },
16205 };
16206
16207 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16208         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16209         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16210         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16211         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16212         { } /* end */
16213 };
16214
16215 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16216         .ops = &snd_hda_bind_sw,
16217         .values = {
16218                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16219                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16220                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16221                 0
16222         },
16223 };
16224
16225 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16226         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16227         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16228         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16229         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16230         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16231         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16232
16233         { } /* end */
16234 };
16235
16236 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16237         .ops = &snd_hda_bind_sw,
16238         .values = {
16239                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16240                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16241                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16242                 0
16243         },
16244 };
16245
16246 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16247         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16248         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16249         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16250         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16251         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16252         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16253         { } /* end */
16254 };
16255
16256 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16257         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16258         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16259         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16260         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16261         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16262         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16263         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16264         { } /* end */
16265 };
16266
16267 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16268         .ops = &snd_hda_bind_vol,
16269         .values = {
16270                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16271                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16272                 0
16273         },
16274 };
16275
16276 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16277         .ops = &snd_hda_bind_sw,
16278         .values = {
16279                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16280                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16281                 0
16282         },
16283 };
16284
16285 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16286         HDA_BIND_VOL("Master Playback Volume",
16287                                 &alc663_asus_two_bind_master_vol),
16288         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16289         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16290         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16291         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16292         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16293         { } /* end */
16294 };
16295
16296 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16297         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16298         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16299         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16300         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16301         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16302         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16303         { } /* end */
16304 };
16305
16306 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16307         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16308         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16309         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16310         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16311         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16312
16313         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16314         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16315         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16316         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16317         { } /* end */
16318 };
16319
16320 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16321         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16322         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16323         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16324
16325         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16326         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16327         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16328         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16329         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16330         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16331         { } /* end */
16332 };
16333
16334 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
16335         .ops = &snd_hda_bind_sw,
16336         .values = {
16337                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16338                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16339                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16340                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16341                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16342                 0
16343         },
16344 };
16345
16346 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
16347         .ops = &snd_hda_bind_sw,
16348         .values = {
16349                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16350                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16351                 0
16352         },
16353 };
16354
16355 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
16356         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16357         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16358         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16359         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16360         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16361         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16362         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16363         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16364         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16365         { } /* end */
16366 };
16367
16368 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
16369         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16370         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16371         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16372         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16373         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16374         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16375         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16376         { } /* end */
16377 };
16378
16379
16380 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16381         {
16382                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16383                 .name = "Channel Mode",
16384                 .info = alc_ch_mode_info,
16385                 .get = alc_ch_mode_get,
16386                 .put = alc_ch_mode_put,
16387         },
16388         { } /* end */
16389 };
16390
16391 static struct hda_verb alc662_init_verbs[] = {
16392         /* ADC: mute amp left and right */
16393         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16394         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16395         /* Front mixer: unmute input/output amp left and right (volume = 0) */
16396
16397         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16398         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16399         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16400         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16401         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16402
16403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16404         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16405         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16406         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16407         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16408         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16409
16410         /* Front Pin: output 0 (0x0c) */
16411         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16412         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16413
16414         /* Rear Pin: output 1 (0x0d) */
16415         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16416         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16417
16418         /* CLFE Pin: output 2 (0x0e) */
16419         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16420         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16421
16422         /* Mic (rear) pin: input vref at 80% */
16423         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16424         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16425         /* Front Mic pin: input vref at 80% */
16426         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16427         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16428         /* Line In pin: input */
16429         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16430         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16431         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16432         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16433         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16434         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16435         /* CD pin widget for input */
16436         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16437
16438         /* FIXME: use matrix-type input source selection */
16439         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16440         /* Input mixer */
16441         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16442         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16443
16444         /* always trun on EAPD */
16445         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16446         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16447
16448         { }
16449 };
16450
16451 static struct hda_verb alc662_sue_init_verbs[] = {
16452         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16453         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16454         {}
16455 };
16456
16457 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16458         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16459         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16460         {}
16461 };
16462
16463 /* Set Unsolicited Event*/
16464 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16465         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16466         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16467         {}
16468 };
16469
16470 /*
16471  * generic initialization of ADC, input mixers and output mixers
16472  */
16473 static struct hda_verb alc662_auto_init_verbs[] = {
16474         /*
16475          * Unmute ADC and set the default input to mic-in
16476          */
16477         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16478         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16479
16480         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
16481          * mixer widget
16482          * Note: PASD motherboards uses the Line In 2 as the input for front
16483          * panel mic (mic 2)
16484          */
16485         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16486         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16487         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16488         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16489         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16490         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16491
16492         /*
16493          * Set up output mixers (0x0c - 0x0f)
16494          */
16495         /* set vol=0 to output mixers */
16496         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16497         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16498         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16499
16500         /* set up input amps for analog loopback */
16501         /* Amp Indices: DAC = 0, mixer = 1 */
16502         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16503         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16504         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16505         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16506         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16507         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16508
16509
16510         /* FIXME: use matrix-type input source selection */
16511         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16512         /* Input mixer */
16513         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16514         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16515         { }
16516 };
16517
16518 /* additional verbs for ALC663 */
16519 static struct hda_verb alc663_auto_init_verbs[] = {
16520         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16521         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16522         { }
16523 };
16524
16525 static struct hda_verb alc663_m51va_init_verbs[] = {
16526         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16527         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16528         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16529         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16530         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16531         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16532         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16533         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16534         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16535         {}
16536 };
16537
16538 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16539         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16540         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16541         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16542         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16543         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16544         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16545         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16546         {}
16547 };
16548
16549 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16550         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16551         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16552         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16553         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16554         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16555         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16556         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16557         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16558         {}
16559 };
16560
16561 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16562         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16563         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16564         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16565         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16566         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16567         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16568         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16569         {}
16570 };
16571
16572 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16573         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16574         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16575         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16576         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16577         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16578         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16579         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16580         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16581         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16582         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16583         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16584         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16585         {}
16586 };
16587
16588 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16589         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16590         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16591         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16592         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16593         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16594         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16595         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16596         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16597         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16598         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16599         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16600         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16601         {}
16602 };
16603
16604 static struct hda_verb alc663_g71v_init_verbs[] = {
16605         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16606         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16607         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16608
16609         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16610         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16611         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16612
16613         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16614         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16615         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16616         {}
16617 };
16618
16619 static struct hda_verb alc663_g50v_init_verbs[] = {
16620         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16621         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16622         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16623
16624         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16625         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16626         {}
16627 };
16628
16629 static struct hda_verb alc662_ecs_init_verbs[] = {
16630         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16631         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16632         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16633         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16634         {}
16635 };
16636
16637 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16638         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16639         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16640         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16641         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16642         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16643         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16644         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16645         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16646         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16647         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16648         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16649         {}
16650 };
16651
16652 static struct hda_verb alc272_dell_init_verbs[] = {
16653         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16654         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16655         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16656         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16657         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16658         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16659         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16660         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16661         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16662         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16663         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16664         {}
16665 };
16666
16667 static struct hda_verb alc663_mode7_init_verbs[] = {
16668         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16669         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16670         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16671         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16672         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16673         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16674         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
16675         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16676         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16677         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16678         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16679         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16680         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16681         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16682         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16683         {}
16684 };
16685
16686 static struct hda_verb alc663_mode8_init_verbs[] = {
16687         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16688         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16689         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16690         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16691         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16692         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16693         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16694         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16695         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16696         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16697         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16698         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16699         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16700         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16701         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16702         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16703         {}
16704 };
16705
16706 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16707         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16708         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16709         { } /* end */
16710 };
16711
16712 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16713         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16714         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16715         { } /* end */
16716 };
16717
16718 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16719 {
16720         unsigned int present;
16721         unsigned char bits;
16722
16723         present = snd_hda_jack_detect(codec, 0x14);
16724         bits = present ? HDA_AMP_MUTE : 0;
16725
16726         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16727                                  HDA_AMP_MUTE, bits);
16728 }
16729
16730 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16731 {
16732         unsigned int present;
16733         unsigned char bits;
16734
16735         present = snd_hda_jack_detect(codec, 0x1b);
16736         bits = present ? HDA_AMP_MUTE : 0;
16737
16738         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16739                                  HDA_AMP_MUTE, bits);
16740         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16741                                  HDA_AMP_MUTE, bits);
16742 }
16743
16744 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16745                                            unsigned int res)
16746 {
16747         if ((res >> 26) == ALC880_HP_EVENT)
16748                 alc662_lenovo_101e_all_automute(codec);
16749         if ((res >> 26) == ALC880_FRONT_EVENT)
16750                 alc662_lenovo_101e_ispeaker_automute(codec);
16751 }
16752
16753 /* unsolicited event for HP jack sensing */
16754 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16755                                      unsigned int res)
16756 {
16757         if ((res >> 26) == ALC880_MIC_EVENT)
16758                 alc_mic_automute(codec);
16759         else
16760                 alc262_hippo_unsol_event(codec, res);
16761 }
16762
16763 static void alc662_eeepc_setup(struct hda_codec *codec)
16764 {
16765         struct alc_spec *spec = codec->spec;
16766
16767         alc262_hippo1_setup(codec);
16768         spec->ext_mic.pin = 0x18;
16769         spec->ext_mic.mux_idx = 0;
16770         spec->int_mic.pin = 0x19;
16771         spec->int_mic.mux_idx = 1;
16772         spec->auto_mic = 1;
16773 }
16774
16775 static void alc662_eeepc_inithook(struct hda_codec *codec)
16776 {
16777         alc262_hippo_automute(codec);
16778         alc_mic_automute(codec);
16779 }
16780
16781 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
16782 {
16783         struct alc_spec *spec = codec->spec;
16784
16785         spec->autocfg.hp_pins[0] = 0x14;
16786         spec->autocfg.speaker_pins[0] = 0x1b;
16787 }
16788
16789 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
16790
16791 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16792 {
16793         unsigned int present;
16794         unsigned char bits;
16795
16796         present = snd_hda_jack_detect(codec, 0x21);
16797         bits = present ? HDA_AMP_MUTE : 0;
16798         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16799                                 AMP_IN_MUTE(0), bits);
16800         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16801                                 AMP_IN_MUTE(0), bits);
16802 }
16803
16804 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16805 {
16806         unsigned int present;
16807         unsigned char bits;
16808
16809         present = snd_hda_jack_detect(codec, 0x21);
16810         bits = present ? HDA_AMP_MUTE : 0;
16811         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16812                                 AMP_IN_MUTE(0), bits);
16813         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16814                                 AMP_IN_MUTE(0), bits);
16815         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16816                                 AMP_IN_MUTE(0), bits);
16817         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16818                                 AMP_IN_MUTE(0), bits);
16819 }
16820
16821 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16822 {
16823         unsigned int present;
16824         unsigned char bits;
16825
16826         present = snd_hda_jack_detect(codec, 0x15);
16827         bits = present ? HDA_AMP_MUTE : 0;
16828         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16829                                 AMP_IN_MUTE(0), bits);
16830         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16831                                 AMP_IN_MUTE(0), bits);
16832         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16833                                 AMP_IN_MUTE(0), bits);
16834         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16835                                 AMP_IN_MUTE(0), bits);
16836 }
16837
16838 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16839 {
16840         unsigned int present;
16841         unsigned char bits;
16842
16843         present = snd_hda_jack_detect(codec, 0x1b);
16844         bits = present ? 0 : PIN_OUT;
16845         snd_hda_codec_write(codec, 0x14, 0,
16846                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16847 }
16848
16849 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16850 {
16851         unsigned int present1, present2;
16852
16853         present1 = snd_hda_jack_detect(codec, 0x21);
16854         present2 = snd_hda_jack_detect(codec, 0x15);
16855
16856         if (present1 || present2) {
16857                 snd_hda_codec_write_cache(codec, 0x14, 0,
16858                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16859         } else {
16860                 snd_hda_codec_write_cache(codec, 0x14, 0,
16861                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16862         }
16863 }
16864
16865 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16866 {
16867         unsigned int present1, present2;
16868
16869         present1 = snd_hda_jack_detect(codec, 0x1b);
16870         present2 = snd_hda_jack_detect(codec, 0x15);
16871
16872         if (present1 || present2) {
16873                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16874                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16875                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16876                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16877         } else {
16878                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16879                                 AMP_IN_MUTE(0), 0);
16880                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16881                                 AMP_IN_MUTE(0), 0);
16882         }
16883 }
16884
16885 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
16886 {
16887         unsigned int present1, present2;
16888
16889         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16890                         AC_VERB_GET_PIN_SENSE, 0)
16891                         & AC_PINSENSE_PRESENCE;
16892         present2 = snd_hda_codec_read(codec, 0x21, 0,
16893                         AC_VERB_GET_PIN_SENSE, 0)
16894                         & AC_PINSENSE_PRESENCE;
16895
16896         if (present1 || present2) {
16897                 snd_hda_codec_write_cache(codec, 0x14, 0,
16898                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16899                 snd_hda_codec_write_cache(codec, 0x17, 0,
16900                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16901         } else {
16902                 snd_hda_codec_write_cache(codec, 0x14, 0,
16903                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16904                 snd_hda_codec_write_cache(codec, 0x17, 0,
16905                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16906         }
16907 }
16908
16909 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
16910 {
16911         unsigned int present1, present2;
16912
16913         present1 = snd_hda_codec_read(codec, 0x21, 0,
16914                         AC_VERB_GET_PIN_SENSE, 0)
16915                         & AC_PINSENSE_PRESENCE;
16916         present2 = snd_hda_codec_read(codec, 0x15, 0,
16917                         AC_VERB_GET_PIN_SENSE, 0)
16918                         & AC_PINSENSE_PRESENCE;
16919
16920         if (present1 || present2) {
16921                 snd_hda_codec_write_cache(codec, 0x14, 0,
16922                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16923                 snd_hda_codec_write_cache(codec, 0x17, 0,
16924                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16925         } else {
16926                 snd_hda_codec_write_cache(codec, 0x14, 0,
16927                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16928                 snd_hda_codec_write_cache(codec, 0x17, 0,
16929                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16930         }
16931 }
16932
16933 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16934                                            unsigned int res)
16935 {
16936         switch (res >> 26) {
16937         case ALC880_HP_EVENT:
16938                 alc663_m51va_speaker_automute(codec);
16939                 break;
16940         case ALC880_MIC_EVENT:
16941                 alc_mic_automute(codec);
16942                 break;
16943         }
16944 }
16945
16946 static void alc663_m51va_setup(struct hda_codec *codec)
16947 {
16948         struct alc_spec *spec = codec->spec;
16949         spec->ext_mic.pin = 0x18;
16950         spec->ext_mic.mux_idx = 0;
16951         spec->int_mic.pin = 0x12;
16952         spec->int_mic.mux_idx = 9;
16953         spec->auto_mic = 1;
16954 }
16955
16956 static void alc663_m51va_inithook(struct hda_codec *codec)
16957 {
16958         alc663_m51va_speaker_automute(codec);
16959         alc_mic_automute(codec);
16960 }
16961
16962 /* ***************** Mode1 ******************************/
16963 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
16964
16965 static void alc663_mode1_setup(struct hda_codec *codec)
16966 {
16967         struct alc_spec *spec = codec->spec;
16968         spec->ext_mic.pin = 0x18;
16969         spec->ext_mic.mux_idx = 0;
16970         spec->int_mic.pin = 0x19;
16971         spec->int_mic.mux_idx = 1;
16972         spec->auto_mic = 1;
16973 }
16974
16975 #define alc663_mode1_inithook           alc663_m51va_inithook
16976
16977 /* ***************** Mode2 ******************************/
16978 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16979                                            unsigned int res)
16980 {
16981         switch (res >> 26) {
16982         case ALC880_HP_EVENT:
16983                 alc662_f5z_speaker_automute(codec);
16984                 break;
16985         case ALC880_MIC_EVENT:
16986                 alc_mic_automute(codec);
16987                 break;
16988         }
16989 }
16990
16991 #define alc662_mode2_setup      alc663_mode1_setup
16992
16993 static void alc662_mode2_inithook(struct hda_codec *codec)
16994 {
16995         alc662_f5z_speaker_automute(codec);
16996         alc_mic_automute(codec);
16997 }
16998 /* ***************** Mode3 ******************************/
16999 static void alc663_mode3_unsol_event(struct hda_codec *codec,
17000                                            unsigned int res)
17001 {
17002         switch (res >> 26) {
17003         case ALC880_HP_EVENT:
17004                 alc663_two_hp_m1_speaker_automute(codec);
17005                 break;
17006         case ALC880_MIC_EVENT:
17007                 alc_mic_automute(codec);
17008                 break;
17009         }
17010 }
17011
17012 #define alc663_mode3_setup      alc663_mode1_setup
17013
17014 static void alc663_mode3_inithook(struct hda_codec *codec)
17015 {
17016         alc663_two_hp_m1_speaker_automute(codec);
17017         alc_mic_automute(codec);
17018 }
17019 /* ***************** Mode4 ******************************/
17020 static void alc663_mode4_unsol_event(struct hda_codec *codec,
17021                                            unsigned int res)
17022 {
17023         switch (res >> 26) {
17024         case ALC880_HP_EVENT:
17025                 alc663_21jd_two_speaker_automute(codec);
17026                 break;
17027         case ALC880_MIC_EVENT:
17028                 alc_mic_automute(codec);
17029                 break;
17030         }
17031 }
17032
17033 #define alc663_mode4_setup      alc663_mode1_setup
17034
17035 static void alc663_mode4_inithook(struct hda_codec *codec)
17036 {
17037         alc663_21jd_two_speaker_automute(codec);
17038         alc_mic_automute(codec);
17039 }
17040 /* ***************** Mode5 ******************************/
17041 static void alc663_mode5_unsol_event(struct hda_codec *codec,
17042                                            unsigned int res)
17043 {
17044         switch (res >> 26) {
17045         case ALC880_HP_EVENT:
17046                 alc663_15jd_two_speaker_automute(codec);
17047                 break;
17048         case ALC880_MIC_EVENT:
17049                 alc_mic_automute(codec);
17050                 break;
17051         }
17052 }
17053
17054 #define alc663_mode5_setup      alc663_mode1_setup
17055
17056 static void alc663_mode5_inithook(struct hda_codec *codec)
17057 {
17058         alc663_15jd_two_speaker_automute(codec);
17059         alc_mic_automute(codec);
17060 }
17061 /* ***************** Mode6 ******************************/
17062 static void alc663_mode6_unsol_event(struct hda_codec *codec,
17063                                            unsigned int res)
17064 {
17065         switch (res >> 26) {
17066         case ALC880_HP_EVENT:
17067                 alc663_two_hp_m2_speaker_automute(codec);
17068                 break;
17069         case ALC880_MIC_EVENT:
17070                 alc_mic_automute(codec);
17071                 break;
17072         }
17073 }
17074
17075 #define alc663_mode6_setup      alc663_mode1_setup
17076
17077 static void alc663_mode6_inithook(struct hda_codec *codec)
17078 {
17079         alc663_two_hp_m2_speaker_automute(codec);
17080         alc_mic_automute(codec);
17081 }
17082
17083 /* ***************** Mode7 ******************************/
17084 static void alc663_mode7_unsol_event(struct hda_codec *codec,
17085                                            unsigned int res)
17086 {
17087         switch (res >> 26) {
17088         case ALC880_HP_EVENT:
17089                 alc663_two_hp_m7_speaker_automute(codec);
17090                 break;
17091         case ALC880_MIC_EVENT:
17092                 alc_mic_automute(codec);
17093                 break;
17094         }
17095 }
17096
17097 #define alc663_mode7_setup      alc663_mode1_setup
17098
17099 static void alc663_mode7_inithook(struct hda_codec *codec)
17100 {
17101         alc663_two_hp_m7_speaker_automute(codec);
17102         alc_mic_automute(codec);
17103 }
17104
17105 /* ***************** Mode8 ******************************/
17106 static void alc663_mode8_unsol_event(struct hda_codec *codec,
17107                                            unsigned int res)
17108 {
17109         switch (res >> 26) {
17110         case ALC880_HP_EVENT:
17111                 alc663_two_hp_m8_speaker_automute(codec);
17112                 break;
17113         case ALC880_MIC_EVENT:
17114                 alc_mic_automute(codec);
17115                 break;
17116         }
17117 }
17118
17119 #define alc663_mode8_setup      alc663_m51va_setup
17120
17121 static void alc663_mode8_inithook(struct hda_codec *codec)
17122 {
17123         alc663_two_hp_m8_speaker_automute(codec);
17124         alc_mic_automute(codec);
17125 }
17126
17127 static void alc663_g71v_hp_automute(struct hda_codec *codec)
17128 {
17129         unsigned int present;
17130         unsigned char bits;
17131
17132         present = snd_hda_jack_detect(codec, 0x21);
17133         bits = present ? HDA_AMP_MUTE : 0;
17134         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17135                                  HDA_AMP_MUTE, bits);
17136         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17137                                  HDA_AMP_MUTE, bits);
17138 }
17139
17140 static void alc663_g71v_front_automute(struct hda_codec *codec)
17141 {
17142         unsigned int present;
17143         unsigned char bits;
17144
17145         present = snd_hda_jack_detect(codec, 0x15);
17146         bits = present ? HDA_AMP_MUTE : 0;
17147         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17148                                  HDA_AMP_MUTE, bits);
17149 }
17150
17151 static void alc663_g71v_unsol_event(struct hda_codec *codec,
17152                                            unsigned int res)
17153 {
17154         switch (res >> 26) {
17155         case ALC880_HP_EVENT:
17156                 alc663_g71v_hp_automute(codec);
17157                 break;
17158         case ALC880_FRONT_EVENT:
17159                 alc663_g71v_front_automute(codec);
17160                 break;
17161         case ALC880_MIC_EVENT:
17162                 alc_mic_automute(codec);
17163                 break;
17164         }
17165 }
17166
17167 #define alc663_g71v_setup       alc663_m51va_setup
17168
17169 static void alc663_g71v_inithook(struct hda_codec *codec)
17170 {
17171         alc663_g71v_front_automute(codec);
17172         alc663_g71v_hp_automute(codec);
17173         alc_mic_automute(codec);
17174 }
17175
17176 static void alc663_g50v_unsol_event(struct hda_codec *codec,
17177                                            unsigned int res)
17178 {
17179         switch (res >> 26) {
17180         case ALC880_HP_EVENT:
17181                 alc663_m51va_speaker_automute(codec);
17182                 break;
17183         case ALC880_MIC_EVENT:
17184                 alc_mic_automute(codec);
17185                 break;
17186         }
17187 }
17188
17189 #define alc663_g50v_setup       alc663_m51va_setup
17190
17191 static void alc663_g50v_inithook(struct hda_codec *codec)
17192 {
17193         alc663_m51va_speaker_automute(codec);
17194         alc_mic_automute(codec);
17195 }
17196
17197 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
17198         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17199         ALC262_HIPPO_MASTER_SWITCH,
17200
17201         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
17202         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
17203         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
17204
17205         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17206         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17207         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17208         { } /* end */
17209 };
17210
17211 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
17212         /* Master Playback automatically created from Speaker and Headphone */
17213         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17214         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17215         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17216         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17217
17218         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17219         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17220         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
17221
17222         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17223         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17224         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
17225         { } /* end */
17226 };
17227
17228 #ifdef CONFIG_SND_HDA_POWER_SAVE
17229 #define alc662_loopbacks        alc880_loopbacks
17230 #endif
17231
17232
17233 /* pcm configuration: identical with ALC880 */
17234 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
17235 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
17236 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
17237 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
17238
17239 /*
17240  * configuration and preset
17241  */
17242 static const char *alc662_models[ALC662_MODEL_LAST] = {
17243         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
17244         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
17245         [ALC662_3ST_6ch]        = "3stack-6ch",
17246         [ALC662_5ST_DIG]        = "6stack-dig",
17247         [ALC662_LENOVO_101E]    = "lenovo-101e",
17248         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17249         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17250         [ALC662_ECS] = "ecs",
17251         [ALC663_ASUS_M51VA] = "m51va",
17252         [ALC663_ASUS_G71V] = "g71v",
17253         [ALC663_ASUS_H13] = "h13",
17254         [ALC663_ASUS_G50V] = "g50v",
17255         [ALC663_ASUS_MODE1] = "asus-mode1",
17256         [ALC662_ASUS_MODE2] = "asus-mode2",
17257         [ALC663_ASUS_MODE3] = "asus-mode3",
17258         [ALC663_ASUS_MODE4] = "asus-mode4",
17259         [ALC663_ASUS_MODE5] = "asus-mode5",
17260         [ALC663_ASUS_MODE6] = "asus-mode6",
17261         [ALC663_ASUS_MODE7] = "asus-mode7",
17262         [ALC663_ASUS_MODE8] = "asus-mode8",
17263         [ALC272_DELL]           = "dell",
17264         [ALC272_DELL_ZM1]       = "dell-zm1",
17265         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
17266         [ALC662_AUTO]           = "auto",
17267 };
17268
17269 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17270         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17271         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17272         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17273         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17274         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17275         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17276         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17277         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17278         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17279         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
17280         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
17281         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17282         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
17283         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
17284         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
17285         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
17286         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
17287         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17288         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
17289         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
17290         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17291         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17292         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17293         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17294         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
17295         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17296         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17297         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17298         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17299         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17300         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17301         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17302         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17303         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17304         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17305         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17306         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17307         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17308         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17309         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17310         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17311         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17312         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17313         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17314         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17315         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17316         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17317         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17318         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17319         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17320         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17321         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17322         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17323         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17324         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17325         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17326         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17327         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17328         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17329         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17330         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17331         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17332                       ALC662_3ST_6ch_DIG),
17333         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
17334         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17335         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17336                       ALC662_3ST_6ch_DIG),
17337         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17338         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17339         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17340         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17341                                         ALC662_3ST_6ch_DIG),
17342         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17343                            ALC663_ASUS_H13),
17344         SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17345         {}
17346 };
17347
17348 static struct alc_config_preset alc662_presets[] = {
17349         [ALC662_3ST_2ch_DIG] = {
17350                 .mixers = { alc662_3ST_2ch_mixer },
17351                 .init_verbs = { alc662_init_verbs },
17352                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17353                 .dac_nids = alc662_dac_nids,
17354                 .dig_out_nid = ALC662_DIGOUT_NID,
17355                 .dig_in_nid = ALC662_DIGIN_NID,
17356                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17357                 .channel_mode = alc662_3ST_2ch_modes,
17358                 .input_mux = &alc662_capture_source,
17359         },
17360         [ALC662_3ST_6ch_DIG] = {
17361                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17362                 .init_verbs = { alc662_init_verbs },
17363                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17364                 .dac_nids = alc662_dac_nids,
17365                 .dig_out_nid = ALC662_DIGOUT_NID,
17366                 .dig_in_nid = ALC662_DIGIN_NID,
17367                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17368                 .channel_mode = alc662_3ST_6ch_modes,
17369                 .need_dac_fix = 1,
17370                 .input_mux = &alc662_capture_source,
17371         },
17372         [ALC662_3ST_6ch] = {
17373                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17374                 .init_verbs = { alc662_init_verbs },
17375                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17376                 .dac_nids = alc662_dac_nids,
17377                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17378                 .channel_mode = alc662_3ST_6ch_modes,
17379                 .need_dac_fix = 1,
17380                 .input_mux = &alc662_capture_source,
17381         },
17382         [ALC662_5ST_DIG] = {
17383                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
17384                 .init_verbs = { alc662_init_verbs },
17385                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17386                 .dac_nids = alc662_dac_nids,
17387                 .dig_out_nid = ALC662_DIGOUT_NID,
17388                 .dig_in_nid = ALC662_DIGIN_NID,
17389                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17390                 .channel_mode = alc662_5stack_modes,
17391                 .input_mux = &alc662_capture_source,
17392         },
17393         [ALC662_LENOVO_101E] = {
17394                 .mixers = { alc662_lenovo_101e_mixer },
17395                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17396                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17397                 .dac_nids = alc662_dac_nids,
17398                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17399                 .channel_mode = alc662_3ST_2ch_modes,
17400                 .input_mux = &alc662_lenovo_101e_capture_source,
17401                 .unsol_event = alc662_lenovo_101e_unsol_event,
17402                 .init_hook = alc662_lenovo_101e_all_automute,
17403         },
17404         [ALC662_ASUS_EEEPC_P701] = {
17405                 .mixers = { alc662_eeepc_p701_mixer },
17406                 .init_verbs = { alc662_init_verbs,
17407                                 alc662_eeepc_sue_init_verbs },
17408                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17409                 .dac_nids = alc662_dac_nids,
17410                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17411                 .channel_mode = alc662_3ST_2ch_modes,
17412                 .unsol_event = alc662_eeepc_unsol_event,
17413                 .setup = alc662_eeepc_setup,
17414                 .init_hook = alc662_eeepc_inithook,
17415         },
17416         [ALC662_ASUS_EEEPC_EP20] = {
17417                 .mixers = { alc662_eeepc_ep20_mixer,
17418                             alc662_chmode_mixer },
17419                 .init_verbs = { alc662_init_verbs,
17420                                 alc662_eeepc_ep20_sue_init_verbs },
17421                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17422                 .dac_nids = alc662_dac_nids,
17423                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17424                 .channel_mode = alc662_3ST_6ch_modes,
17425                 .input_mux = &alc662_lenovo_101e_capture_source,
17426                 .unsol_event = alc662_eeepc_unsol_event,
17427                 .setup = alc662_eeepc_ep20_setup,
17428                 .init_hook = alc662_eeepc_ep20_inithook,
17429         },
17430         [ALC662_ECS] = {
17431                 .mixers = { alc662_ecs_mixer },
17432                 .init_verbs = { alc662_init_verbs,
17433                                 alc662_ecs_init_verbs },
17434                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17435                 .dac_nids = alc662_dac_nids,
17436                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17437                 .channel_mode = alc662_3ST_2ch_modes,
17438                 .unsol_event = alc662_eeepc_unsol_event,
17439                 .setup = alc662_eeepc_setup,
17440                 .init_hook = alc662_eeepc_inithook,
17441         },
17442         [ALC663_ASUS_M51VA] = {
17443                 .mixers = { alc663_m51va_mixer },
17444                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17445                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17446                 .dac_nids = alc662_dac_nids,
17447                 .dig_out_nid = ALC662_DIGOUT_NID,
17448                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17449                 .channel_mode = alc662_3ST_2ch_modes,
17450                 .unsol_event = alc663_m51va_unsol_event,
17451                 .setup = alc663_m51va_setup,
17452                 .init_hook = alc663_m51va_inithook,
17453         },
17454         [ALC663_ASUS_G71V] = {
17455                 .mixers = { alc663_g71v_mixer },
17456                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17457                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17458                 .dac_nids = alc662_dac_nids,
17459                 .dig_out_nid = ALC662_DIGOUT_NID,
17460                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17461                 .channel_mode = alc662_3ST_2ch_modes,
17462                 .unsol_event = alc663_g71v_unsol_event,
17463                 .setup = alc663_g71v_setup,
17464                 .init_hook = alc663_g71v_inithook,
17465         },
17466         [ALC663_ASUS_H13] = {
17467                 .mixers = { alc663_m51va_mixer },
17468                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17469                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17470                 .dac_nids = alc662_dac_nids,
17471                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17472                 .channel_mode = alc662_3ST_2ch_modes,
17473                 .unsol_event = alc663_m51va_unsol_event,
17474                 .init_hook = alc663_m51va_inithook,
17475         },
17476         [ALC663_ASUS_G50V] = {
17477                 .mixers = { alc663_g50v_mixer },
17478                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17479                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17480                 .dac_nids = alc662_dac_nids,
17481                 .dig_out_nid = ALC662_DIGOUT_NID,
17482                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17483                 .channel_mode = alc662_3ST_6ch_modes,
17484                 .input_mux = &alc663_capture_source,
17485                 .unsol_event = alc663_g50v_unsol_event,
17486                 .setup = alc663_g50v_setup,
17487                 .init_hook = alc663_g50v_inithook,
17488         },
17489         [ALC663_ASUS_MODE1] = {
17490                 .mixers = { alc663_m51va_mixer },
17491                 .cap_mixer = alc662_auto_capture_mixer,
17492                 .init_verbs = { alc662_init_verbs,
17493                                 alc663_21jd_amic_init_verbs },
17494                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17495                 .hp_nid = 0x03,
17496                 .dac_nids = alc662_dac_nids,
17497                 .dig_out_nid = ALC662_DIGOUT_NID,
17498                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17499                 .channel_mode = alc662_3ST_2ch_modes,
17500                 .unsol_event = alc663_mode1_unsol_event,
17501                 .setup = alc663_mode1_setup,
17502                 .init_hook = alc663_mode1_inithook,
17503         },
17504         [ALC662_ASUS_MODE2] = {
17505                 .mixers = { alc662_1bjd_mixer },
17506                 .cap_mixer = alc662_auto_capture_mixer,
17507                 .init_verbs = { alc662_init_verbs,
17508                                 alc662_1bjd_amic_init_verbs },
17509                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17510                 .dac_nids = alc662_dac_nids,
17511                 .dig_out_nid = ALC662_DIGOUT_NID,
17512                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17513                 .channel_mode = alc662_3ST_2ch_modes,
17514                 .unsol_event = alc662_mode2_unsol_event,
17515                 .setup = alc662_mode2_setup,
17516                 .init_hook = alc662_mode2_inithook,
17517         },
17518         [ALC663_ASUS_MODE3] = {
17519                 .mixers = { alc663_two_hp_m1_mixer },
17520                 .cap_mixer = alc662_auto_capture_mixer,
17521                 .init_verbs = { alc662_init_verbs,
17522                                 alc663_two_hp_amic_m1_init_verbs },
17523                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17524                 .hp_nid = 0x03,
17525                 .dac_nids = alc662_dac_nids,
17526                 .dig_out_nid = ALC662_DIGOUT_NID,
17527                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17528                 .channel_mode = alc662_3ST_2ch_modes,
17529                 .unsol_event = alc663_mode3_unsol_event,
17530                 .setup = alc663_mode3_setup,
17531                 .init_hook = alc663_mode3_inithook,
17532         },
17533         [ALC663_ASUS_MODE4] = {
17534                 .mixers = { alc663_asus_21jd_clfe_mixer },
17535                 .cap_mixer = alc662_auto_capture_mixer,
17536                 .init_verbs = { alc662_init_verbs,
17537                                 alc663_21jd_amic_init_verbs},
17538                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17539                 .hp_nid = 0x03,
17540                 .dac_nids = alc662_dac_nids,
17541                 .dig_out_nid = ALC662_DIGOUT_NID,
17542                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17543                 .channel_mode = alc662_3ST_2ch_modes,
17544                 .unsol_event = alc663_mode4_unsol_event,
17545                 .setup = alc663_mode4_setup,
17546                 .init_hook = alc663_mode4_inithook,
17547         },
17548         [ALC663_ASUS_MODE5] = {
17549                 .mixers = { alc663_asus_15jd_clfe_mixer },
17550                 .cap_mixer = alc662_auto_capture_mixer,
17551                 .init_verbs = { alc662_init_verbs,
17552                                 alc663_15jd_amic_init_verbs },
17553                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17554                 .hp_nid = 0x03,
17555                 .dac_nids = alc662_dac_nids,
17556                 .dig_out_nid = ALC662_DIGOUT_NID,
17557                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17558                 .channel_mode = alc662_3ST_2ch_modes,
17559                 .unsol_event = alc663_mode5_unsol_event,
17560                 .setup = alc663_mode5_setup,
17561                 .init_hook = alc663_mode5_inithook,
17562         },
17563         [ALC663_ASUS_MODE6] = {
17564                 .mixers = { alc663_two_hp_m2_mixer },
17565                 .cap_mixer = alc662_auto_capture_mixer,
17566                 .init_verbs = { alc662_init_verbs,
17567                                 alc663_two_hp_amic_m2_init_verbs },
17568                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17569                 .hp_nid = 0x03,
17570                 .dac_nids = alc662_dac_nids,
17571                 .dig_out_nid = ALC662_DIGOUT_NID,
17572                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17573                 .channel_mode = alc662_3ST_2ch_modes,
17574                 .unsol_event = alc663_mode6_unsol_event,
17575                 .setup = alc663_mode6_setup,
17576                 .init_hook = alc663_mode6_inithook,
17577         },
17578         [ALC663_ASUS_MODE7] = {
17579                 .mixers = { alc663_mode7_mixer },
17580                 .cap_mixer = alc662_auto_capture_mixer,
17581                 .init_verbs = { alc662_init_verbs,
17582                                 alc663_mode7_init_verbs },
17583                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17584                 .hp_nid = 0x03,
17585                 .dac_nids = alc662_dac_nids,
17586                 .dig_out_nid = ALC662_DIGOUT_NID,
17587                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17588                 .channel_mode = alc662_3ST_2ch_modes,
17589                 .unsol_event = alc663_mode7_unsol_event,
17590                 .setup = alc663_mode7_setup,
17591                 .init_hook = alc663_mode7_inithook,
17592         },
17593         [ALC663_ASUS_MODE8] = {
17594                 .mixers = { alc663_mode8_mixer },
17595                 .cap_mixer = alc662_auto_capture_mixer,
17596                 .init_verbs = { alc662_init_verbs,
17597                                 alc663_mode8_init_verbs },
17598                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17599                 .hp_nid = 0x03,
17600                 .dac_nids = alc662_dac_nids,
17601                 .dig_out_nid = ALC662_DIGOUT_NID,
17602                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17603                 .channel_mode = alc662_3ST_2ch_modes,
17604                 .unsol_event = alc663_mode8_unsol_event,
17605                 .setup = alc663_mode8_setup,
17606                 .init_hook = alc663_mode8_inithook,
17607         },
17608         [ALC272_DELL] = {
17609                 .mixers = { alc663_m51va_mixer },
17610                 .cap_mixer = alc272_auto_capture_mixer,
17611                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
17612                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17613                 .dac_nids = alc662_dac_nids,
17614                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17615                 .adc_nids = alc272_adc_nids,
17616                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
17617                 .capsrc_nids = alc272_capsrc_nids,
17618                 .channel_mode = alc662_3ST_2ch_modes,
17619                 .unsol_event = alc663_m51va_unsol_event,
17620                 .setup = alc663_m51va_setup,
17621                 .init_hook = alc663_m51va_inithook,
17622         },
17623         [ALC272_DELL_ZM1] = {
17624                 .mixers = { alc663_m51va_mixer },
17625                 .cap_mixer = alc662_auto_capture_mixer,
17626                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
17627                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17628                 .dac_nids = alc662_dac_nids,
17629                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17630                 .adc_nids = alc662_adc_nids,
17631                 .num_adc_nids = 1,
17632                 .capsrc_nids = alc662_capsrc_nids,
17633                 .channel_mode = alc662_3ST_2ch_modes,
17634                 .unsol_event = alc663_m51va_unsol_event,
17635                 .setup = alc663_m51va_setup,
17636                 .init_hook = alc663_m51va_inithook,
17637         },
17638         [ALC272_SAMSUNG_NC10] = {
17639                 .mixers = { alc272_nc10_mixer },
17640                 .init_verbs = { alc662_init_verbs,
17641                                 alc663_21jd_amic_init_verbs },
17642                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17643                 .dac_nids = alc272_dac_nids,
17644                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17645                 .channel_mode = alc662_3ST_2ch_modes,
17646                 /*.input_mux = &alc272_nc10_capture_source,*/
17647                 .unsol_event = alc663_mode4_unsol_event,
17648                 .setup = alc663_mode4_setup,
17649                 .init_hook = alc663_mode4_inithook,
17650         },
17651 };
17652
17653
17654 /*
17655  * BIOS auto configuration
17656  */
17657
17658 /* convert from MIX nid to DAC */
17659 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
17660 {
17661         if (nid == 0x0f)
17662                 return 0x02;
17663         else if (nid >= 0x0c && nid <= 0x0e)
17664                 return nid - 0x0c + 0x02;
17665         else
17666                 return 0;
17667 }
17668
17669 /* get MIX nid connected to the given pin targeted to DAC */
17670 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
17671                                    hda_nid_t dac)
17672 {
17673         hda_nid_t mix[4];
17674         int i, num;
17675
17676         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
17677         for (i = 0; i < num; i++) {
17678                 if (alc662_mix_to_dac(mix[i]) == dac)
17679                         return mix[i];
17680         }
17681         return 0;
17682 }
17683
17684 /* look for an empty DAC slot */
17685 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
17686 {
17687         struct alc_spec *spec = codec->spec;
17688         hda_nid_t srcs[5];
17689         int i, j, num;
17690
17691         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
17692         if (num < 0)
17693                 return 0;
17694         for (i = 0; i < num; i++) {
17695                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
17696                 if (!nid)
17697                         continue;
17698                 for (j = 0; j < spec->multiout.num_dacs; j++)
17699                         if (spec->multiout.dac_nids[j] == nid)
17700                                 break;
17701                 if (j >= spec->multiout.num_dacs)
17702                         return nid;
17703         }
17704         return 0;
17705 }
17706
17707 /* fill in the dac_nids table from the parsed pin configuration */
17708 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
17709                                      const struct auto_pin_cfg *cfg)
17710 {
17711         struct alc_spec *spec = codec->spec;
17712         int i;
17713         hda_nid_t dac;
17714
17715         spec->multiout.dac_nids = spec->private_dac_nids;
17716         for (i = 0; i < cfg->line_outs; i++) {
17717                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
17718                 if (!dac)
17719                         continue;
17720                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
17721         }
17722         return 0;
17723 }
17724
17725 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
17726                               hda_nid_t nid, unsigned int chs)
17727 {
17728         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17729                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
17730 }
17731
17732 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
17733                              hda_nid_t nid, unsigned int chs)
17734 {
17735         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17736                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
17737 }
17738
17739 #define alc662_add_stereo_vol(spec, pfx, nid) \
17740         alc662_add_vol_ctl(spec, pfx, nid, 3)
17741 #define alc662_add_stereo_sw(spec, pfx, nid) \
17742         alc662_add_sw_ctl(spec, pfx, nid, 3)
17743
17744 /* add playback controls from the parsed DAC table */
17745 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
17746                                              const struct auto_pin_cfg *cfg)
17747 {
17748         struct alc_spec *spec = codec->spec;
17749         static const char *chname[4] = {
17750                 "Front", "Surround", NULL /*CLFE*/, "Side"
17751         };
17752         hda_nid_t nid, mix;
17753         int i, err;
17754
17755         for (i = 0; i < cfg->line_outs; i++) {
17756                 nid = spec->multiout.dac_nids[i];
17757                 if (!nid)
17758                         continue;
17759                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
17760                 if (!mix)
17761                         continue;
17762                 if (i == 2) {
17763                         /* Center/LFE */
17764                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
17765                         if (err < 0)
17766                                 return err;
17767                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
17768                         if (err < 0)
17769                                 return err;
17770                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
17771                         if (err < 0)
17772                                 return err;
17773                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
17774                         if (err < 0)
17775                                 return err;
17776                 } else {
17777                         const char *pfx;
17778                         if (cfg->line_outs == 1 &&
17779                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17780                                 if (cfg->hp_outs)
17781                                         pfx = "Speaker";
17782                                 else
17783                                         pfx = "PCM";
17784                         } else
17785                                 pfx = chname[i];
17786                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17787                         if (err < 0)
17788                                 return err;
17789                         if (cfg->line_outs == 1 &&
17790                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17791                                 pfx = "Speaker";
17792                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17793                         if (err < 0)
17794                                 return err;
17795                 }
17796         }
17797         return 0;
17798 }
17799
17800 /* add playback controls for speaker and HP outputs */
17801 /* return DAC nid if any new DAC is assigned */
17802 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
17803                                         const char *pfx)
17804 {
17805         struct alc_spec *spec = codec->spec;
17806         hda_nid_t nid, mix;
17807         int err;
17808
17809         if (!pin)
17810                 return 0;
17811         nid = alc662_look_for_dac(codec, pin);
17812         if (!nid) {
17813                 /* the corresponding DAC is already occupied */
17814                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
17815                         return 0; /* no way */
17816                 /* create a switch only */
17817                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17818                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17819         }
17820
17821         mix = alc662_dac_to_mix(codec, pin, nid);
17822         if (!mix)
17823                 return 0;
17824         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17825         if (err < 0)
17826                 return err;
17827         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17828         if (err < 0)
17829                 return err;
17830         return nid;
17831 }
17832
17833 /* create playback/capture controls for input pins */
17834 #define alc662_auto_create_input_ctls \
17835         alc882_auto_create_input_ctls
17836
17837 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17838                                               hda_nid_t nid, int pin_type,
17839                                               hda_nid_t dac)
17840 {
17841         int i, num;
17842         hda_nid_t srcs[4];
17843
17844         alc_set_pin_output(codec, nid, pin_type);
17845         /* need the manual connection? */
17846         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
17847         if (num <= 1)
17848                 return;
17849         for (i = 0; i < num; i++) {
17850                 if (alc662_mix_to_dac(srcs[i]) != dac)
17851                         continue;
17852                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
17853                 return;
17854         }
17855 }
17856
17857 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17858 {
17859         struct alc_spec *spec = codec->spec;
17860         int pin_type = get_pin_type(spec->autocfg.line_out_type);
17861         int i;
17862
17863         for (i = 0; i <= HDA_SIDE; i++) {
17864                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17865                 if (nid)
17866                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17867                                         spec->multiout.dac_nids[i]);
17868         }
17869 }
17870
17871 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17872 {
17873         struct alc_spec *spec = codec->spec;
17874         hda_nid_t pin;
17875
17876         pin = spec->autocfg.hp_pins[0];
17877         if (pin)
17878                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
17879                                                   spec->multiout.hp_nid);
17880         pin = spec->autocfg.speaker_pins[0];
17881         if (pin)
17882                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
17883                                         spec->multiout.extra_out_nid[0]);
17884 }
17885
17886 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
17887
17888 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17889 {
17890         struct alc_spec *spec = codec->spec;
17891         int i;
17892
17893         for (i = 0; i < AUTO_PIN_LAST; i++) {
17894                 hda_nid_t nid = spec->autocfg.input_pins[i];
17895                 if (alc_is_input_pin(codec, nid)) {
17896                         alc_set_input_pin(codec, nid, i);
17897                         if (nid != ALC662_PIN_CD_NID &&
17898                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17899                                 snd_hda_codec_write(codec, nid, 0,
17900                                                     AC_VERB_SET_AMP_GAIN_MUTE,
17901                                                     AMP_OUT_MUTE);
17902                 }
17903         }
17904 }
17905
17906 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17907
17908 static int alc662_parse_auto_config(struct hda_codec *codec)
17909 {
17910         struct alc_spec *spec = codec->spec;
17911         int err;
17912         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17913
17914         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17915                                            alc662_ignore);
17916         if (err < 0)
17917                 return err;
17918         if (!spec->autocfg.line_outs)
17919                 return 0; /* can't find valid BIOS pin config */
17920
17921         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
17922         if (err < 0)
17923                 return err;
17924         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
17925         if (err < 0)
17926                 return err;
17927         err = alc662_auto_create_extra_out(codec,
17928                                            spec->autocfg.speaker_pins[0],
17929                                            "Speaker");
17930         if (err < 0)
17931                 return err;
17932         if (err)
17933                 spec->multiout.extra_out_nid[0] = err;
17934         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
17935                                            "Headphone");
17936         if (err < 0)
17937                 return err;
17938         if (err)
17939                 spec->multiout.hp_nid = err;
17940         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
17941         if (err < 0)
17942                 return err;
17943
17944         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17945
17946         if (spec->autocfg.dig_outs)
17947                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17948
17949         if (spec->kctls.list)
17950                 add_mixer(spec, spec->kctls.list);
17951
17952         spec->num_mux_defs = 1;
17953         spec->input_mux = &spec->private_imux[0];
17954
17955         add_verb(spec, alc662_auto_init_verbs);
17956         if (codec->vendor_id == 0x10ec0663)
17957                 add_verb(spec, alc663_auto_init_verbs);
17958
17959         err = alc_auto_add_mic_boost(codec);
17960         if (err < 0)
17961                 return err;
17962
17963         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17964
17965         return 1;
17966 }
17967
17968 /* additional initialization for auto-configuration model */
17969 static void alc662_auto_init(struct hda_codec *codec)
17970 {
17971         struct alc_spec *spec = codec->spec;
17972         alc662_auto_init_multi_out(codec);
17973         alc662_auto_init_hp_out(codec);
17974         alc662_auto_init_analog_input(codec);
17975         alc662_auto_init_input_src(codec);
17976         if (spec->unsol_event)
17977                 alc_inithook(codec);
17978 }
17979
17980 static int patch_alc662(struct hda_codec *codec)
17981 {
17982         struct alc_spec *spec;
17983         int err, board_config;
17984
17985         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17986         if (!spec)
17987                 return -ENOMEM;
17988
17989         codec->spec = spec;
17990
17991         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17992
17993         if (alc_read_coef_idx(codec, 0)==0x8020){
17994                 kfree(codec->chip_name);
17995                 codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
17996                 if (!codec->chip_name) {
17997                         alc_free(codec);
17998                         return -ENOMEM;
17999                 }
18000         }
18001
18002         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
18003                                                   alc662_models,
18004                                                   alc662_cfg_tbl);
18005         if (board_config < 0) {
18006                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
18007                        codec->chip_name);
18008                 board_config = ALC662_AUTO;
18009         }
18010
18011         if (board_config == ALC662_AUTO) {
18012                 /* automatic parse from the BIOS config */
18013                 err = alc662_parse_auto_config(codec);
18014                 if (err < 0) {
18015                         alc_free(codec);
18016                         return err;
18017                 } else if (!err) {
18018                         printk(KERN_INFO
18019                                "hda_codec: Cannot set up configuration "
18020                                "from BIOS.  Using base mode...\n");
18021                         board_config = ALC662_3ST_2ch_DIG;
18022                 }
18023         }
18024
18025         err = snd_hda_attach_beep_device(codec, 0x1);
18026         if (err < 0) {
18027                 alc_free(codec);
18028                 return err;
18029         }
18030
18031         if (board_config != ALC662_AUTO)
18032                 setup_preset(codec, &alc662_presets[board_config]);
18033
18034         spec->stream_analog_playback = &alc662_pcm_analog_playback;
18035         spec->stream_analog_capture = &alc662_pcm_analog_capture;
18036
18037         spec->stream_digital_playback = &alc662_pcm_digital_playback;
18038         spec->stream_digital_capture = &alc662_pcm_digital_capture;
18039
18040         if (!spec->adc_nids) {
18041                 spec->adc_nids = alc662_adc_nids;
18042                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
18043         }
18044         if (!spec->capsrc_nids)
18045                 spec->capsrc_nids = alc662_capsrc_nids;
18046
18047         if (!spec->cap_mixer)
18048                 set_capture_mixer(codec);
18049         if (codec->vendor_id == 0x10ec0662)
18050                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
18051         else
18052                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
18053
18054         spec->vmaster_nid = 0x02;
18055
18056         codec->patch_ops = alc_patch_ops;
18057         if (board_config == ALC662_AUTO)
18058                 spec->init_hook = alc662_auto_init;
18059 #ifdef CONFIG_SND_HDA_POWER_SAVE
18060         if (!spec->loopback.amplist)
18061                 spec->loopback.amplist = alc662_loopbacks;
18062 #endif
18063         codec->proc_widget_hook = print_realtek_coef;
18064
18065         return 0;
18066 }
18067
18068 static int patch_alc888(struct hda_codec *codec)
18069 {
18070         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
18071                 kfree(codec->chip_name);
18072                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
18073                 if (!codec->chip_name) {
18074                         alc_free(codec);
18075                         return -ENOMEM;
18076                 }
18077                 return patch_alc662(codec);
18078         }
18079         return patch_alc882(codec);
18080 }
18081
18082 /*
18083  * patch entries
18084  */
18085 static struct hda_codec_preset snd_hda_preset_realtek[] = {
18086         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
18087         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
18088         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
18089         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
18090         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
18091         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
18092         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
18093         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
18094         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
18095           .patch = patch_alc861 },
18096         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
18097         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
18098         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
18099         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
18100           .patch = patch_alc882 },
18101         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
18102           .patch = patch_alc662 },
18103         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
18104         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
18105         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
18106         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
18107         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
18108           .patch = patch_alc882 },
18109         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
18110           .patch = patch_alc882 },
18111         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
18112         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
18113         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
18114           .patch = patch_alc882 },
18115         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
18116         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
18117         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
18118         {} /* terminator */
18119 };
18120
18121 MODULE_ALIAS("snd-hda-codec-id:10ec*");
18122
18123 MODULE_LICENSE("GPL");
18124 MODULE_DESCRIPTION("Realtek HD-audio codec");
18125
18126 static struct hda_codec_preset_list realtek_list = {
18127         .preset = snd_hda_preset_realtek,
18128         .owner = THIS_MODULE,
18129 };
18130
18131 static int __init patch_realtek_init(void)
18132 {
18133         return snd_hda_add_codec_preset(&realtek_list);
18134 }
18135
18136 static void __exit patch_realtek_exit(void)
18137 {
18138         snd_hda_delete_codec_preset(&realtek_list);
18139 }
18140
18141 module_init(patch_realtek_init)
18142 module_exit(patch_realtek_exit)